func TestgetRandomDevAddr(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a Redis database and NetID 010203", t, func() {
p := NewRedisPool(conf.RedisURL)
common.MustFlushRedis(p)
netID := lorawan.NetID{1, 2, 3}
Convey("When calling getRandomDevAddr many times, it should always return an unique DevAddr", func() {
log := make(map[lorawan.DevAddr]struct{})
for i := 0; i < 1000; i++ {
devAddr, err := GetRandomDevAddr(p, netID)
if err != nil {
t.Fatal(err)
}
if devAddr.NwkID() != netID.NwkID() {
t.Fatalf("%b must equal %b", devAddr.NwkID(), netID.NwkID())
}
if len(log) != i {
t.Fatalf("%d must equal %d", len(log), i)
}
log[devAddr] = struct{}{}
}
})
})
}
func TestApplicationMethods(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean database", t, func() {
db, err := OpenDatabase(conf.PostgresDSN)
So(err, ShouldBeNil)
common.MustResetDB(db)
Convey("When creating an application", func() {
app := models.Application{
AppEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
Name: "test app",
}
So(CreateApplication(db, app), ShouldBeNil)
Convey("Then we can get it", func() {
app2, err := GetApplication(db, app.AppEUI)
So(err, ShouldBeNil)
So(app2, ShouldResemble, app)
})
Convey("Then get applications returns a single item", func() {
apps, err := GetApplications(db, 10, 0)
So(err, ShouldBeNil)
So(apps, ShouldHaveLength, 1)
So(apps[0], ShouldResemble, app)
})
Convey("Then applications count returns 1", func() {
count, err := GetApplicationsCount(db)
So(err, ShouldBeNil)
So(count, ShouldEqual, 1)
})
Convey("When updating the application", func() {
app.Name = "new name"
So(UpdateApplication(db, app), ShouldBeNil)
Convey("The application has been updated", func() {
app2, err := GetApplication(db, app.AppEUI)
So(err, ShouldBeNil)
So(app2, ShouldResemble, app)
})
})
Convey("After deleting the application", func() {
So(DeleteApplication(db, app.AppEUI), ShouldBeNil)
Convey("The application has gone", func() {
count, err := GetApplicationsCount(db)
So(err, ShouldBeNil)
So(count, ShouldEqual, 0)
})
})
})
})
}
func TestApplicationAPI(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean database and api instance", t, func() {
db, err := storage.OpenDatabase(conf.PostgresDSN)
So(err, ShouldBeNil)
common.MustResetDB(db)
ctx := context.Background()
lsCtx := loraserver.Context{DB: db}
api := NewApplicationAPI(lsCtx)
Convey("When creating an application", func() {
_, err := api.Create(ctx, &pb.CreateApplicationRequest{AppEUI: "0102030405060708", Name: "test app"})
So(err, ShouldBeNil)
Convey("Then we can get it", func() {
resp, err := api.Get(ctx, &pb.GetApplicationRequest{AppEUI: "0102030405060708"})
So(err, ShouldBeNil)
So(resp, ShouldResemble, &pb.GetApplicationResponse{AppEUI: "0102030405060708", Name: "test app"})
})
Convey("Then listing the applications returns a single item", func() {
resp, err := api.List(ctx, &pb.ListApplicationRequest{Limit: 10})
So(err, ShouldBeNil)
So(resp.Result, ShouldHaveLength, 1)
So(resp.TotalCount, ShouldEqual, 1)
So(resp.Result[0], ShouldResemble, &pb.GetApplicationResponse{AppEUI: "0102030405060708", Name: "test app"})
})
Convey("When updating the application", func() {
_, err := api.Update(ctx, &pb.UpdateApplicationRequest{AppEUI: "0102030405060708", Name: "test app 2"})
So(err, ShouldBeNil)
Convey("Then the application has been updated", func() {
resp, err := api.Get(ctx, &pb.GetApplicationRequest{AppEUI: "0102030405060708"})
So(err, ShouldBeNil)
So(resp.Name, ShouldEqual, "test app 2")
})
})
Convey("After deleting the application", func() {
_, err := api.Delete(ctx, &pb.DeleteApplicationRequest{AppEUI: "0102030405060708"})
So(err, ShouldBeNil)
Convey("Then listing the applications resturns zero items", func() {
resp, err := api.List(ctx, &pb.ListApplicationRequest{Limit: 10})
So(err, ShouldBeNil)
So(resp.Result, ShouldHaveLength, 0)
})
})
})
})
}
func TestMACPayloadTXQueue(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean Redis database", t, func() {
p := NewRedisPool(conf.RedisURL)
common.MustFlushRedis(p)
Convey("Given a node-session", func() {
ns := models.NodeSession{
DevAddr: [4]byte{1, 2, 3, 4},
DevEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
}
So(CreateNodeSession(p, ns), ShouldBeNil)
Convey("When adding MACPayload a and b to the queue", func() {
a := models.MACPayload{
Reference: "a",
DevEUI: ns.DevEUI,
}
b := models.MACPayload{
Reference: "b",
DevEUI: ns.DevEUI,
}
So(AddMACPayloadToTXQueue(p, a), ShouldBeNil)
So(AddMACPayloadToTXQueue(p, b), ShouldBeNil)
Convey("Then readMACPayloadTXQueue returns both MACPayload in the correct order", func() {
payloads, err := ReadMACPayloadTXQueue(p, ns.DevAddr)
So(err, ShouldBeNil)
So(payloads, ShouldResemble, []models.MACPayload{a, b})
})
Convey("When deleting MACPayload a", func() {
So(DeleteMACPayloadFromTXQueue(p, ns.DevAddr, a), ShouldBeNil)
Convey("Then only MACPayload b is in the queue", func() {
payloads, err := ReadMACPayloadTXQueue(p, ns.DevAddr)
So(err, ShouldBeNil)
So(payloads, ShouldResemble, []models.MACPayload{b})
})
})
})
})
})
}
func TestTXPayloadQueue(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean Redis database", t, func() {
p := NewRedisPool(conf.RedisURL)
common.MustFlushRedis(p)
Convey("Given two TXPayload structs (a and b) for the same DevEUI", func() {
devEUI := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
a := models.TXPayload{
DevEUI: devEUI,
Data: []byte("hello!"),
}
b := models.TXPayload{
DevEUI: devEUI,
Data: []byte("world"),
}
Convey("When getting an item from the non-existing queue", func() {
_, err := GetTXPayloadFromQueue(p, devEUI)
Convey("Then errEmptyQueue error is returned", func() {
So(err, ShouldResemble, common.ErrEmptyQueue)
})
})
Convey("Given the NodePayloadQueueTTL is 100 ms", func() {
common.NodeTXPayloadQueueTTL = 100 * time.Millisecond
Convey("Given struct a and b are pushed to the queue", func() {
So(AddTXPayloadToQueue(p, a), ShouldBeNil)
So(AddTXPayloadToQueue(p, b), ShouldBeNil)
Convey("Then the queue size is 2", func() {
count, err := GetTXPayloadQueueSize(p, devEUI)
So(err, ShouldBeNil)
So(count, ShouldEqual, 2)
})
Convey("Then after 150 ms the queue has expired", func() {
time.Sleep(150 * time.Millisecond)
_, err := GetTXPayloadFromQueue(p, devEUI)
So(err, ShouldResemble, common.ErrEmptyQueue)
})
Convey("When consuming an item from the queue", func() {
pl, err := GetTXPayloadFromQueue(p, devEUI)
So(err, ShouldBeNil)
Convey("Then the queue size is still 2", func() {
count, err := GetTXPayloadQueueSize(p, devEUI)
So(err, ShouldBeNil)
So(count, ShouldEqual, 2)
})
Convey("Then it equals to struct a", func() {
So(pl, ShouldResemble, a)
})
Convey("When consuming an item from the queue again", func() {
pl, err := GetTXPayloadFromQueue(p, devEUI)
So(err, ShouldBeNil)
Convey("Then it equals to struct a (again)", func() {
So(pl, ShouldResemble, a)
})
})
Convey("When flushing the queue", func() {
So(FlushTXPayloadQueue(p, devEUI), ShouldBeNil)
Convey("Then the queue size is 0", func() {
count, err := GetTXPayloadQueueSize(p, devEUI)
So(err, ShouldBeNil)
So(count, ShouldEqual, 0)
})
})
Convey("Then after 150 ms the queue has expired (both in-process and the queue)", func() {
time.Sleep(100 * time.Millisecond)
_, err := GetTXPayloadFromQueue(p, devEUI)
So(err, ShouldResemble, common.ErrEmptyQueue)
})
Convey("After clearing the in-process payload", func() {
_, err := ClearInProcessTXPayload(p, devEUI)
So(err, ShouldBeNil)
Convey("Then the queue size is 1", func() {
count, err := GetTXPayloadQueueSize(p, devEUI)
So(err, ShouldBeNil)
So(count, ShouldEqual, 1)
})
Convey("When consuming an item from the queue", func() {
pl, err := GetTXPayloadFromQueue(p, devEUI)
So(err, ShouldBeNil)
Convey("Then it equals to struct b", func() {
So(pl, ShouldResemble, b)
})
})
})
})
})
})
})
})
}
func TestNodeMethods(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean database with application", t, func() {
db, err := OpenDatabase(conf.PostgresDSN)
So(err, ShouldBeNil)
common.MustResetDB(db)
app := models.Application{
AppEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
Name: "test app",
}
So(CreateApplication(db, app), ShouldBeNil)
Convey("When creating a node", func() {
node := models.Node{
DevEUI: [8]byte{8, 7, 6, 5, 4, 3, 2, 1},
AppEUI: app.AppEUI,
AppKey: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8},
RXDelay: 2,
RX1DROffset: 3,
}
So(CreateNode(db, node), ShouldBeNil)
Convey("Whe can get it", func() {
node2, err := GetNode(db, node.DevEUI)
node2.UsedDevNonces = nil
So(err, ShouldBeNil)
So(node2, ShouldResemble, node)
})
Convey("Then get nodes returns a single item", func() {
nodes, err := GetNodes(db, 10, 0)
So(err, ShouldBeNil)
So(nodes, ShouldHaveLength, 1)
nodes[0].UsedDevNonces = nil
So(nodes[0], ShouldResemble, node)
})
Convey("Then get nodes for AppEUI returns a single item", func() {
nodes, err := GetNodesForAppEUI(db, app.AppEUI, 10, 0)
So(err, ShouldBeNil)
So(nodes, ShouldHaveLength, 1)
nodes[0].UsedDevNonces = nil
So(nodes[0], ShouldResemble, node)
})
Convey("Then get nodes count returns 1", func() {
count, err := GetNodesCount(db)
So(err, ShouldBeNil)
So(count, ShouldEqual, 1)
})
Convey("Then get nodes count for AppEUI returns 1", func() {
count, err := GetNodesForAppEUICount(db, app.AppEUI)
So(err, ShouldBeNil)
So(count, ShouldEqual, 1)
})
Convey("When updating the node", func() {
node.AppKey = [16]byte{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
So(UpdateNode(db, node), ShouldBeNil)
Convey("Then the nodes has been updated", func() {
node2, err := GetNode(db, node.DevEUI)
So(err, ShouldBeNil)
node2.UsedDevNonces = nil
So(node2, ShouldResemble, node)
})
})
Convey("When deleting the node", func() {
So(DeleteNode(db, node.DevEUI), ShouldBeNil)
Convey("Then get nodes count returns 0", func() {
count, err := GetNodesCount(db)
So(err, ShouldBeNil)
So(count, ShouldEqual, 0)
})
})
})
})
}
func TestNodeSessionAPI(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean database and api instance", t, func() {
db, err := storage.OpenDatabase(conf.PostgresDSN)
So(err, ShouldBeNil)
common.MustResetDB(db)
p := storage.NewRedisPool(conf.RedisURL)
common.MustFlushRedis(p)
lsCtx := loraserver.Context{DB: db, RedisPool: p, NetID: [3]byte{1, 2, 3}}
ctx := context.Background()
api := NewNodeSessionAPI(lsCtx)
Convey("Given an application and node are created (fk constraints)", func() {
app := models.Application{
AppEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
Name: "test app",
}
So(storage.CreateApplication(db, app), ShouldBeNil)
node := models.Node{
DevEUI: [8]byte{8, 7, 6, 5, 4, 3, 2, 1},
AppEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
AppKey: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
UsedDevNonces: [][2]byte{},
}
So(storage.CreateNode(db, node), ShouldBeNil)
Convey("When creating a node-session", func() {
_, err := api.Create(ctx, &pb.CreateNodeSessionRequest{
DevAddr: "06020304",
DevEUI: node.DevEUI.String(),
AppEUI: node.AppEUI.String(),
AppSKey: node.AppKey.String(),
NwkSKey: node.AppKey.String(),
FCntUp: 10,
FCntDown: 11,
RxDelay: 1,
Rx1DROffset: 2,
CFList: []uint32{
868700000,
},
})
So(err, ShouldBeNil)
Convey("Then it can be retrieved by DevAddr", func() {
resp, err := api.Get(ctx, &pb.GetNodeSessionRequest{DevAddr: "06020304"})
So(err, ShouldBeNil)
So(resp, ShouldResemble, &pb.GetNodeSessionResponse{
DevAddr: "06020304",
DevEUI: node.DevEUI.String(),
AppEUI: node.AppEUI.String(),
AppSKey: node.AppKey.String(),
NwkSKey: node.AppKey.String(),
FCntUp: 10,
FCntDown: 11,
RxDelay: 1,
Rx1DROffset: 2,
CFList: []uint32{
868700000,
0,
0,
0,
0,
},
})
})
Convey("Then it can be retrieved by DevEUI", func() {
resp, err := api.GetByDevEUI(ctx, &pb.GetNodeSessionByDevEUIRequest{DevEUI: node.DevEUI.String()})
So(err, ShouldBeNil)
So(resp, ShouldResemble, &pb.GetNodeSessionResponse{
DevAddr: "06020304",
DevEUI: node.DevEUI.String(),
AppEUI: node.AppEUI.String(),
AppSKey: node.AppKey.String(),
NwkSKey: node.AppKey.String(),
FCntUp: 10,
FCntDown: 11,
RxDelay: 1,
Rx1DROffset: 2,
CFList: []uint32{
868700000,
0,
0,
0,
0,
},
})
})
Convey("When updating the node-session", func() {
_, err := api.Update(ctx, &pb.UpdateNodeSessionRequest{
DevAddr: "06020304",
DevEUI: node.DevEUI.String(),
AppEUI: node.AppEUI.String(),
AppSKey: node.AppKey.String(),
NwkSKey: node.AppKey.String(),
FCntUp: 20,
FCntDown: 22,
RxDelay: 10,
Rx1DROffset: 20,
CFList: []uint32{
868700000,
868800000,
},
})
So(err, ShouldBeNil)
Convey("Then the node-session has been updated", func() {
resp, err := api.Get(ctx, &pb.GetNodeSessionRequest{DevAddr: "06020304"})
So(err, ShouldBeNil)
So(resp, ShouldResemble, &pb.GetNodeSessionResponse{
DevAddr: "06020304",
DevEUI: node.DevEUI.String(),
AppEUI: node.AppEUI.String(),
AppSKey: node.AppKey.String(),
NwkSKey: node.AppKey.String(),
FCntUp: 20,
FCntDown: 22,
RxDelay: 10,
Rx1DROffset: 20,
CFList: []uint32{
868700000,
868800000,
0,
0,
0,
},
})
})
})
Convey("When deleting the node-session", func() {
_, err := api.Delete(ctx, &pb.DeleteNodeSessionRequest{DevAddr: "06020304"})
So(err, ShouldBeNil)
Convey("Then the node-session has been deleted", func() {
_, err := api.Get(ctx, &pb.GetNodeSessionRequest{DevAddr: "06020304"})
So(err, ShouldNotBeNil)
})
})
})
})
})
}
func TestHandleDataUpScenarios(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean state, test backends and a node-session", t, func() {
app := &testApplicationBackend{
rxPayloadChan: make(chan models.RXPayload, 1),
txPayloadChan: make(chan models.TXPayload, 1),
notificationPayloadChan: make(chan interface{}, 10),
}
gw := &testGatewayBackend{
rxPacketChan: make(chan models.RXPacket, 1),
txPacketChan: make(chan models.TXPacket, 1),
}
ctrl := &testControllerBackend{
rxMACPayloadChan: make(chan models.MACPayload, 2),
txMACPayloadChan: make(chan models.MACPayload, 1),
rxInfoPayloadChan: make(chan models.RXInfoPayload, 1),
errorPayloadChan: make(chan models.ErrorPayload, 1),
}
p := storage.NewRedisPool(conf.RedisURL)
common.MustFlushRedis(p)
ctx := Context{
RedisPool: p,
Gateway: gw,
Application: app,
Controller: ctrl,
}
ns := models.NodeSession{
DevAddr: [4]byte{1, 2, 3, 4},
DevEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
AppSKey: [16]byte{16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1},
NwkSKey: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
FCntUp: 8,
FCntDown: 5,
AppEUI: [8]byte{8, 7, 6, 5, 4, 3, 2, 1},
}
So(storage.CreateNodeSession(ctx.RedisPool, ns), ShouldBeNil)
rxInfo := models.RXInfo{
Frequency: common.Band.UplinkChannels[0].Frequency,
DataRate: common.Band.DataRates[common.Band.UplinkChannels[0].DataRates[0]],
}
var fPortZero uint8
var fPortOne uint8 = 1
Convey("Given a set of test-scenarios for basic flows (nothing in queue)", func() {
tests := []dataUpTestCase{
// errors
{
Name: "the application backend returns an error",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
ApplicationBackendError: errors.New("BOOM!"),
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedFCntUp: 8,
ExpectedFCntDown: 5,
ExpectedHandleRXPacketError: errors.New("send rx payload to application error: BOOM!"),
},
{
Name: "the frame-counter is invalid",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 7,
},
FPort: &fPortOne,
},
},
ExpectedFCntUp: 8,
ExpectedFCntDown: 5,
ExpectedHandleRXPacketError: errors.New("invalid FCnt or too many dropped frames"),
},
{
Name: "the mic is invalid",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.AppSKey,
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedFCntUp: 8,
ExpectedFCntDown: 5,
ExpectedHandleRXPacketError: errors.New("invalid MIC"),
},
// basic flows
{
Name: "unconfirmed uplink data with payload",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
FRMPayload: []lorawan.Payload{&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}}},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1, Data: []byte{1, 2, 3, 4}},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 5,
},
{
Name: "unconfirmed uplink data without payload (just a FPort)",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 5,
},
{
Name: "confirmed uplink data with payload",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.ConfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
FRMPayload: []lorawan.Payload{&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}}},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1, Data: []byte{1, 2, 3, 4}},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
FCtrl: lorawan.FCtrl{
ACK: true,
},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
{
Name: "confirmed uplink data without payload",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.ConfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
FCtrl: lorawan.FCtrl{
ACK: true,
},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
{
Name: "two uplink mac commands (FOpts)",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.NwkSKey,
SetMICKey: ns.NwkSKey,
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
FOpts: []lorawan.MACCommand{
{CID: lorawan.LinkCheckReq},
{CID: lorawan.LinkADRAns, Payload: &lorawan.LinkADRAnsPayload{ChannelMaskACK: true}},
},
},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedControllerRXMACPayloads: []models.MACPayload{
{DevEUI: ns.DevEUI, MACCommand: []byte{2}},
{DevEUI: ns.DevEUI, MACCommand: []byte{3, 1}},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 5,
},
{
Name: "two uplink mac commands (FRMPayload)",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.NwkSKey,
SetMICKey: ns.NwkSKey,
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortZero,
FRMPayload: []lorawan.Payload{
&lorawan.MACCommand{CID: lorawan.LinkCheckReq},
&lorawan.MACCommand{CID: lorawan.LinkADRAns, Payload: &lorawan.LinkADRAnsPayload{ChannelMaskACK: true}},
},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedControllerRXMACPayloads: []models.MACPayload{
{DevEUI: ns.DevEUI, FRMPayload: true, MACCommand: []byte{2}},
{DevEUI: ns.DevEUI, FRMPayload: true, MACCommand: []byte{3, 1}},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 5,
},
}
runDataUpTests(ctx, ns.DevEUI, ns.DevAddr, tests)
})
Convey("Given a set of test-scenarios for mac-command queue", func() {
var fPortThree uint8 = 3
tests := []dataUpTestCase{
{
Name: "unconfirmed uplink data + two downlink mac commands in queue (FOpts)",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXMACPayloadQueue: []models.MACPayload{
{DevEUI: ns.DevEUI, MACCommand: []byte{6}},
{DevEUI: ns.DevEUI, MACCommand: []byte{8, 3}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
FRMPayload: []lorawan.Payload{&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}}},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1, Data: []byte{1, 2, 3, 4}},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
FOpts: []lorawan.MACCommand{
{CID: lorawan.CID(6)},
{CID: lorawan.CID(8), Payload: &lorawan.RXTimingSetupReqPayload{Delay: 3}},
},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
{
Name: "unconfirmed uplink data + two downlink mac commands in queue (FOpts) + unconfirmed tx-payload in queue",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXPayloadQueue: []models.TXPayload{
{DevEUI: ns.DevEUI, FPort: 3, Data: []byte{4, 5, 6}},
},
TXMACPayloadQueue: []models.MACPayload{
{DevEUI: ns.DevEUI, MACCommand: []byte{6}},
{DevEUI: ns.DevEUI, MACCommand: []byte{8, 3}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
FRMPayload: []lorawan.Payload{&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}}},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1, Data: []byte{1, 2, 3, 4}},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
FOpts: []lorawan.MACCommand{
{CID: lorawan.CID(6)},
{CID: lorawan.CID(8), Payload: &lorawan.RXTimingSetupReqPayload{Delay: 3}},
},
},
FPort: &fPortThree,
FRMPayload: []lorawan.Payload{
&lorawan.DataPayload{Bytes: []byte{4, 5, 6}},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
{
Name: "unconfirmed uplink data + two downlink mac commands in queue (FRMPayload)",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.NwkSKey,
SetMICKey: ns.NwkSKey,
TXMACPayloadQueue: []models.MACPayload{
{DevEUI: ns.DevEUI, FRMPayload: true, MACCommand: []byte{6}},
{DevEUI: ns.DevEUI, FRMPayload: true, MACCommand: []byte{8, 3}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
FRMPayload: []lorawan.Payload{&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}}},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1, Data: []byte{1, 2, 3, 4}},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
},
FPort: &fPortZero,
FRMPayload: []lorawan.Payload{
&lorawan.MACCommand{CID: lorawan.CID(6)},
&lorawan.MACCommand{CID: lorawan.CID(8), Payload: &lorawan.RXTimingSetupReqPayload{Delay: 3}},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
{
Name: "unconfirmed uplink data + two downlink mac commands in queue (FRMPayload) + unconfirmed tx-payload in queue",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.NwkSKey,
SetMICKey: ns.NwkSKey,
TXPayloadQueue: []models.TXPayload{
{DevEUI: ns.DevEUI, FPort: 3, Data: []byte{4, 5, 6}},
},
TXMACPayloadQueue: []models.MACPayload{
{DevEUI: ns.DevEUI, FRMPayload: true, MACCommand: []byte{6}},
{DevEUI: ns.DevEUI, FRMPayload: true, MACCommand: []byte{8, 3}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
FRMPayload: []lorawan.Payload{&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}}},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1, Data: []byte{1, 2, 3, 4}},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
FCtrl: lorawan.FCtrl{
FPending: true,
},
},
FPort: &fPortZero,
FRMPayload: []lorawan.Payload{
&lorawan.MACCommand{CID: lorawan.CID(6)},
&lorawan.MACCommand{CID: lorawan.CID(8), Payload: &lorawan.RXTimingSetupReqPayload{Delay: 3}},
},
},
},
},
},
ExpectedGetTXPayloadFromQueue: &models.TXPayload{DevEUI: ns.DevEUI, FPort: 3, Data: []byte{4, 5, 6}},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
{
Name: "unconfirmed uplink data + 18 bytes of MAC commands (FOpts) of which one is invalid",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXMACPayloadQueue: []models.MACPayload{
{Reference: "a", DevEUI: ns.DevEUI, MACCommand: []byte{2, 10, 5}},
{Reference: "b", DevEUI: ns.DevEUI, MACCommand: []byte{6}},
{Reference: "c", DevEUI: ns.DevEUI, MACCommand: []byte{4, 15}},
{Reference: "d", DevEUI: ns.DevEUI, MACCommand: []byte{4, 15, 16}}, // invalid payload, should be discarded + error notification
{Reference: "e", DevEUI: ns.DevEUI, MACCommand: []byte{2, 10, 5}},
{Reference: "f", DevEUI: ns.DevEUI, MACCommand: []byte{2, 10, 5}},
{Reference: "g", DevEUI: ns.DevEUI, MACCommand: []byte{2, 10, 6}}, // this payload should stay in the queue
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
FRMPayload: []lorawan.Payload{&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}}},
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedControllerErrorPayloads: []models.ErrorPayload{
{Reference: "d", DevEUI: ns.DevEUI, Message: "unmarshal mac command error: lorawan: 1 byte of data is expected"},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1, Data: []byte{1, 2, 3, 4}},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
FCtrl: lorawan.FCtrl{
FPending: true,
},
FOpts: []lorawan.MACCommand{
{CID: lorawan.LinkCheckAns, Payload: &lorawan.LinkCheckAnsPayload{Margin: 10, GwCnt: 5}},
{CID: lorawan.DevStatusReq},
{CID: lorawan.DutyCycleReq, Payload: &lorawan.DutyCycleReqPayload{MaxDCCycle: 15}},
{CID: lorawan.LinkCheckAns, Payload: &lorawan.LinkCheckAnsPayload{Margin: 10, GwCnt: 5}},
{CID: lorawan.LinkCheckAns, Payload: &lorawan.LinkCheckAnsPayload{Margin: 10, GwCnt: 5}},
},
},
},
},
},
},
ExpectedTXMACPayloadQueue: []models.MACPayload{
{Reference: "g", DevEUI: ns.DevEUI, MACCommand: []byte{2, 10, 6}},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
}
runDataUpTests(ctx, ns.DevEUI, ns.DevAddr, tests)
})
Convey("Given a set of test-scenarios for tx-payload queue", func() {
var fPortTen uint8 = 10
tests := []dataUpTestCase{
{
Name: "unconfirmed uplink data + one unconfirmed downlink payload in queue",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXPayloadQueue: []models.TXPayload{
{Reference: "a", DevEUI: ns.DevEUI, FPort: 10, Data: []byte{1, 2, 3, 4}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
},
FPort: &fPortTen,
FRMPayload: []lorawan.Payload{
&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
{
Name: "unconfirmed uplink data + two unconfirmed downlink payloads in queue",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXPayloadQueue: []models.TXPayload{
{Reference: "a", DevEUI: ns.DevEUI, FPort: 10, Data: []byte{1, 2, 3, 4}},
{Reference: "b", DevEUI: ns.DevEUI, FPort: 10, Data: []byte{4, 3, 2, 1}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
FCtrl: lorawan.FCtrl{
FPending: true,
},
},
FPort: &fPortTen,
FRMPayload: []lorawan.Payload{
&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
ExpectedGetTXPayloadFromQueue: &models.TXPayload{Reference: "b", DevEUI: ns.DevEUI, FPort: 10, Data: []byte{4, 3, 2, 1}},
},
{
Name: "unconfirmed uplink data + one confirmed downlink payload in queue",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXPayloadQueue: []models.TXPayload{
{Reference: "a", Confirmed: true, DevEUI: ns.DevEUI, FPort: 10, Data: []byte{1, 2, 3, 4}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.ConfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
},
FPort: &fPortTen,
FRMPayload: []lorawan.Payload{
&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 5, // will be incremented after the node ACKs the frame
ExpectedGetTXPayloadFromQueue: &models.TXPayload{Reference: "a", Confirmed: true, DevEUI: ns.DevEUI, FPort: 10, Data: []byte{1, 2, 3, 4}},
},
{
Name: "unconfirmed uplink data with ACK + one confirmed downlink payload in in-process queue",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXMACPayloadInProcess: &models.TXPayload{Reference: "a", Confirmed: true, DevEUI: ns.DevEUI, FPort: 10, Data: []byte{1, 2, 3, 4}},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
FCtrl: lorawan.FCtrl{
ACK: true,
},
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1},
},
ExpectedApplicationNotifications: []interface{}{
models.ACKNotification{Reference: "a", DevEUI: ns.DevEUI},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6, // has been updated because of the ACK
},
{
Name: "unconfirmed uplink data + two unconfirmed downlink payload in queue of which the first exceeds the max payload size (for dr 0)",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXPayloadQueue: []models.TXPayload{
{Reference: "a", DevEUI: ns.DevEUI, FPort: 10, Data: make([]byte, 52)},
{Reference: "b", DevEUI: ns.DevEUI, FPort: 10, Data: []byte{1, 2, 3, 4}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1},
},
ExpectedApplicationNotifications: []interface{}{
models.ErrorPayload{Reference: "a", DevEUI: ns.DevEUI, Message: "downlink payload max size exceeded (dr: 0, allowed: 51, got: 52)"},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
},
FPort: &fPortTen,
FRMPayload: []lorawan.Payload{
&lorawan.DataPayload{Bytes: []byte{1, 2, 3, 4}},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
},
{
Name: "unconfirmed uplink data + one unconfirmed downlink payload in queue (exactly max size for dr 0) + one mac command",
RXInfo: rxInfo,
EncryptFRMPayloadKey: ns.AppSKey,
DecryptExpectedFRMPayloadKey: ns.AppSKey,
SetMICKey: ns.NwkSKey,
TXPayloadQueue: []models.TXPayload{
{Reference: "a", DevEUI: ns.DevEUI, FPort: 10, Data: make([]byte, 51)},
},
TXMACPayloadQueue: []models.MACPayload{
{DevEUI: ns.DevEUI, MACCommand: []byte{6}},
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 10,
},
FPort: &fPortOne,
},
},
ExpectedControllerRXInfoPayloads: []models.RXInfoPayload{
{DevEUI: ns.DevEUI, FCnt: 10, RXInfo: []models.RXInfo{rxInfo}},
},
ExpectedApplicationRXPayloads: []models.RXPayload{
{DevEUI: ns.DevEUI, FPort: 1, GatewayCount: 1},
},
ExpectedGatewayTXPackets: []models.TXPacket{
{
TXInfo: models.TXInfo{
Timestamp: rxInfo.Timestamp + 1000000,
Frequency: rxInfo.Frequency,
Power: 14,
DataRate: rxInfo.DataRate,
},
PHYPayload: lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataDown,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.MACPayload{
FHDR: lorawan.FHDR{
DevAddr: ns.DevAddr,
FCnt: 5,
FCtrl: lorawan.FCtrl{
FPending: true,
},
FOpts: []lorawan.MACCommand{
{CID: lorawan.CID(6)},
},
},
},
},
},
},
ExpectedFCntUp: 10,
ExpectedFCntDown: 6,
ExpectedGetTXPayloadFromQueue: &models.TXPayload{Reference: "a", DevEUI: ns.DevEUI, FPort: 10, Data: make([]byte, 51)},
},
}
runDataUpTests(ctx, ns.DevEUI, ns.DevAddr, tests)
})
})
}
func TestHandleJoinRequestPackets(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a dummy gateway and application backend and a clean Postgres and Redis database", t, func() {
a := &testApplicationBackend{
rxPayloadChan: make(chan models.RXPayload, 1),
notificationPayloadChan: make(chan interface{}, 10),
}
g := &testGatewayBackend{
rxPacketChan: make(chan models.RXPacket, 1),
txPacketChan: make(chan models.TXPacket, 1),
}
p := storage.NewRedisPool(conf.RedisURL)
common.MustFlushRedis(p)
db, err := storage.OpenDatabase(conf.PostgresDSN)
So(err, ShouldBeNil)
common.MustResetDB(db)
ctx := Context{
RedisPool: p,
Gateway: g,
Application: a,
DB: db,
}
Convey("Given a node and application in the database", func() {
app := models.Application{
AppEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
Name: "test app",
}
So(storage.CreateApplication(ctx.DB, app), ShouldBeNil)
node := models.Node{
DevEUI: [8]byte{8, 7, 6, 5, 4, 3, 2, 1},
AppEUI: app.AppEUI,
AppKey: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
RXDelay: 3,
RX1DROffset: 2,
}
So(storage.CreateNode(ctx.DB, node), ShouldBeNil)
Convey("Given a JoinRequest with correct DevEUI but incorrect AppEUI", func() {
phy := lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.JoinRequest,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.JoinRequestPayload{
AppEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 9},
DevEUI: node.DevEUI,
DevNonce: [2]byte{1, 2},
},
}
So(phy.SetMIC(node.AppKey), ShouldBeNil)
rxPacket := models.RXPacket{
PHYPayload: phy,
RXInfo: models.RXInfo{
Frequency: common.Band.UplinkChannels[0].Frequency,
DataRate: common.Band.DataRates[common.Band.UplinkChannels[0].DataRates[0]],
},
}
Convey("then handleRXPacket returns an error", func() {
So(handleRXPacket(ctx, rxPacket), ShouldResemble, errors.New("node 0807060504030201 belongs to application 0102030405060708, 0102030405060709 was given"))
})
})
Convey("Given a JoinRequest packet", func() {
phy := lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.JoinRequest,
Major: lorawan.LoRaWANR1,
},
MACPayload: &lorawan.JoinRequestPayload{
AppEUI: app.AppEUI,
DevEUI: node.DevEUI,
DevNonce: [2]byte{1, 2},
},
}
So(phy.SetMIC(node.AppKey), ShouldBeNil)
rxPacket := models.RXPacket{
PHYPayload: phy,
RXInfo: models.RXInfo{
Frequency: common.Band.UplinkChannels[0].Frequency,
DataRate: common.Band.DataRates[common.Band.UplinkChannels[0].DataRates[0]],
},
}
Convey("When calling handleRXPacket", func() {
So(handleRXPacket(ctx, rxPacket), ShouldBeNil)
Convey("Then a JoinAccept was sent to the node", func() {
txPacket := <-g.txPacketChan
phy := txPacket.PHYPayload
So(phy.DecryptJoinAcceptPayload(node.AppKey), ShouldBeNil)
So(phy.MHDR.MType, ShouldEqual, lorawan.JoinAccept)
Convey("Then it was sent after 5s", func() {
So(txPacket.TXInfo.Timestamp, ShouldEqual, rxPacket.RXInfo.Timestamp+uint32(5*time.Second/time.Microsecond))
})
Convey("Then the RXDelay is set to 3s", func() {
jaPL := phy.MACPayload.(*lorawan.JoinAcceptPayload)
So(jaPL.RXDelay, ShouldEqual, 3)
})
Convey("Then the DLSettings are set correctly", func() {
jaPL := phy.MACPayload.(*lorawan.JoinAcceptPayload)
So(jaPL.DLSettings.RX2DataRate, ShouldEqual, uint8(common.Band.RX2DataRate))
So(jaPL.DLSettings.RX1DROffset, ShouldEqual, node.RX1DROffset)
})
Convey("Then a node-session was created", func() {
jaPL := phy.MACPayload.(*lorawan.JoinAcceptPayload)
_, err := storage.GetNodeSession(ctx.RedisPool, jaPL.DevAddr)
So(err, ShouldBeNil)
})
Convey("Then the dev-nonce was added to the used dev-nonces", func() {
node, err := storage.GetNode(ctx.DB, node.DevEUI)
So(err, ShouldBeNil)
So([2]byte{1, 2}, ShouldBeIn, node.UsedDevNonces)
})
Convey("Then a join notification was sent to the application", func() {
notification := <-a.notificationPayloadChan
join, ok := notification.(models.JoinNotification)
So(ok, ShouldBeTrue)
So(join.DevEUI, ShouldResemble, node.DevEUI)
})
})
})
})
})
})
}
func TestNodeAPI(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean database with an application and api instance", t, func() {
db, err := storage.OpenDatabase(conf.PostgresDSN)
So(err, ShouldBeNil)
common.MustResetDB(db)
p := storage.NewRedisPool(conf.RedisURL)
common.MustFlushRedis(p)
ctx := context.Background()
lsCtx := loraserver.Context{DB: db, RedisPool: p}
api := NewNodeAPI(lsCtx)
app := models.Application{
AppEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
Name: "test app",
}
So(storage.CreateApplication(db, app), ShouldBeNil)
Convey("When creating a node", func() {
_, err := api.Create(ctx, &pb.CreateNodeRequest{
DevEUI: "0807060504030201",
AppEUI: "0102030405060708",
AppKey: "01020304050607080102030405060708",
RxDelay: 1,
Rx1DROffset: 3,
})
So(err, ShouldBeNil)
Convey("The node has been created", func() {
node, err := api.Get(ctx, &pb.GetNodeRequest{DevEUI: "0807060504030201"})
So(err, ShouldBeNil)
So(node, ShouldResemble, &pb.GetNodeResponse{
DevEUI: "0807060504030201",
AppEUI: "0102030405060708",
AppKey: "01020304050607080102030405060708",
RxDelay: 1,
Rx1DROffset: 3,
})
})
Convey("Then listing the nodes returns a single items", func() {
nodes, err := api.List(ctx, &pb.ListNodeRequest{
Limit: 10,
})
So(err, ShouldBeNil)
So(nodes.Result, ShouldHaveLength, 1)
So(nodes.TotalCount, ShouldEqual, 1)
So(nodes.Result[0], ShouldResemble, &pb.GetNodeResponse{
DevEUI: "0807060504030201",
AppEUI: "0102030405060708",
AppKey: "01020304050607080102030405060708",
RxDelay: 1,
Rx1DROffset: 3,
})
})
Convey("Then listing the nodes for a given AppEUI returns a single item", func() {
nodes, err := api.ListByAppEUI(ctx, &pb.ListNodeByAppEUIRequest{
Limit: 10,
AppEUI: "0102030405060708",
})
So(err, ShouldBeNil)
So(nodes.Result, ShouldHaveLength, 1)
So(nodes.TotalCount, ShouldEqual, 1)
So(nodes.Result[0], ShouldResemble, &pb.GetNodeResponse{
DevEUI: "0807060504030201",
AppEUI: "0102030405060708",
AppKey: "01020304050607080102030405060708",
RxDelay: 1,
Rx1DROffset: 3,
})
})
Convey("When updating the node", func() {
_, err := api.Update(ctx, &pb.UpdateNodeRequest{
DevEUI: "0807060504030201",
AppEUI: "0102030405060708",
AppKey: "08070605040302010807060504030201",
RxDelay: 3,
Rx1DROffset: 1,
})
So(err, ShouldBeNil)
Convey("Then the node has been updated", func() {
node, err := api.Get(ctx, &pb.GetNodeRequest{DevEUI: "0807060504030201"})
So(err, ShouldBeNil)
So(node, ShouldResemble, &pb.GetNodeResponse{
DevEUI: "0807060504030201",
AppEUI: "0102030405060708",
AppKey: "08070605040302010807060504030201",
RxDelay: 3,
Rx1DROffset: 1,
})
})
})
Convey("After deleting the node", func() {
_, err := api.Delete(ctx, &pb.DeleteNodeRequest{DevEUI: "0807060504030201"})
So(err, ShouldBeNil)
Convey("Then listing the nodes returns zero nodes", func() {
nodes, err := api.List(ctx, &pb.ListNodeRequest{Limit: 10})
So(err, ShouldBeNil)
So(nodes.TotalCount, ShouldEqual, 0)
So(nodes.Result, ShouldHaveLength, 0)
})
})
Convey("Given a tx payload in the the queue", func() {
So(storage.AddTXPayloadToQueue(p, models.TXPayload{
DevEUI: [8]byte{8, 7, 6, 5, 4, 3, 2, 1},
Data: []byte("hello!"),
}), ShouldBeNil)
count, err := storage.GetTXPayloadQueueSize(p, [8]byte{8, 7, 6, 5, 4, 3, 2, 1})
So(err, ShouldBeNil)
So(count, ShouldEqual, 1)
Convey("When flushing the tx-payload queue", func() {
_, err := api.FlushTXPayloadQueue(ctx, &pb.FlushTXPayloadQueueRequest{DevEUI: "0807060504030201"})
So(err, ShouldBeNil)
Convey("Then the queue is empty", func() {
count, err := storage.GetTXPayloadQueueSize(p, [8]byte{8, 7, 6, 5, 4, 3, 2, 1})
So(err, ShouldBeNil)
So(count, ShouldEqual, 0)
})
})
})
})
})
}
func TestNodeSession(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean Redis database", t, func() {
p := NewRedisPool(conf.RedisURL)
common.MustFlushRedis(p)
Convey("Given a NodeSession", func() {
ns := models.NodeSession{
DevAddr: [4]byte{1, 2, 3, 4},
DevEUI: [8]byte{1, 2, 3, 4, 5, 6, 7, 8},
}
Convey("When getting a non-existing NodeSession", func() {
_, err := GetNodeSession(p, ns.DevAddr)
Convey("Then an error is returned", func() {
So(err, ShouldResemble, errors.New("get node-session for DevAddr 01020304 error: redigo: nil returned"))
})
})
Convey("When saving the NodeSession", func() {
So(SaveNodeSession(p, ns), ShouldBeNil)
Convey("Then when getting the NodeSession, the same data is returned", func() {
ns2, err := GetNodeSession(p, ns.DevAddr)
So(err, ShouldBeNil)
So(ns2, ShouldResemble, ns)
})
Convey("Then the session can be retrieved by it's DevEUI", func() {
ns2, err := GetNodeSessionByDevEUI(p, ns.DevEUI)
So(err, ShouldBeNil)
So(ns2, ShouldResemble, ns)
})
})
Convey("When calling validateAndGetFullFCntUp", func() {
testTable := []struct {
ServerFCnt uint32
NodeFCnt uint32
FullFCnt uint32
Valid bool
}{
{0, 1, 1, true}, // ideal case counter was incremented
{1, 1, 1, true}, // re-transmission
{2, 1, 0, false}, // old packet received
{0, common.Band.MaxFCntGap, 0, false}, // gap should be less than MaxFCntGap
{0, common.Band.MaxFCntGap - 1, common.Band.MaxFCntGap - 1, true}, // gap is exactly within the allowed MaxFCntGap
{65536, common.Band.MaxFCntGap - 1, common.Band.MaxFCntGap - 1 + 65536, true}, // roll-over happened, gap ix exactly within allowed MaxFCntGap
{65535, common.Band.MaxFCntGap, 0, false}, // roll-over happened, but too many lost frames
{65535, 0, 65536, true}, // roll-over happened
{65536, 0, 65536, true}, // re-transmission
{4294967295, 0, 0, true}, // 32 bit roll-over happened, counter started at 0 again
}
for _, test := range testTable {
Convey(fmt.Sprintf("Then when FCntUp=%d, ValidateAndGetFullFCntUp(%d) should return (%d, %t)", test.ServerFCnt, test.NodeFCnt, test.FullFCnt, test.Valid), func() {
ns.FCntUp = test.ServerFCnt
fullFCntUp, ok := ValidateAndGetFullFCntUp(ns, test.NodeFCnt)
So(ok, ShouldEqual, test.Valid)
So(fullFCntUp, ShouldEqual, test.FullFCnt)
})
}
})
})
})
}
func TestChannelFunctions(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean database", t, func() {
db, err := OpenDatabase(conf.PostgresDSN)
So(err, ShouldBeNil)
common.MustResetDB(db)
Convey("When creating a channel-list", func() {
cl := models.ChannelList{
Name: "test channel-list",
}
So(CreateChannelList(db, &cl), ShouldBeNil)
Convey("Then the channel-list exists", func() {
cl2, err := GetChannelList(db, cl.ID)
So(err, ShouldBeNil)
So(cl2, ShouldResemble, cl)
})
Convey("When updating the channel-list", func() {
cl.Name = "test channel-list changed"
So(UpdateChannelList(db, cl), ShouldBeNil)
Convey("Then the channel-list has been updated", func() {
cl2, err := GetChannelList(db, cl.ID)
So(err, ShouldBeNil)
So(cl2, ShouldResemble, cl)
})
})
Convey("Then listing the channel-lists returns 1 result", func() {
lists, err := GetChannelLists(db, 10, 0)
So(err, ShouldBeNil)
So(lists, ShouldHaveLength, 1)
So(lists[0], ShouldResemble, cl)
})
Convey("Then the channel-list count returns 1", func() {
count, err := GetChannelListsCount(db)
So(err, ShouldBeNil)
So(count, ShouldEqual, 1)
})
Convey("When deleting the channel-list", func() {
So(DeleteChannelList(db, cl.ID), ShouldBeNil)
Convey("Then the channel-list has been removed", func() {
count, err := GetChannelListsCount(db)
So(err, ShouldBeNil)
So(count, ShouldEqual, 0)
})
})
Convey("When creating a channel", func() {
c := models.Channel{
ChannelListID: cl.ID,
Channel: 4,
Frequency: 868700000,
}
So(CreateChannel(db, &c), ShouldBeNil)
Convey("Then the channel has been created", func() {
c2, err := GetChannel(db, c.ID)
So(err, ShouldBeNil)
So(c2, ShouldResemble, c)
})
Convey("When updating the channel", func() {
c.Channel = 5
So(UpdateChannel(db, c), ShouldBeNil)
Convey("Then the channel has been updated", func() {
c2, err := GetChannel(db, c.ID)
So(err, ShouldBeNil)
So(c2, ShouldResemble, c)
})
})
Convey("When deleting the channel", func() {
So(DeleteChannel(db, c.ID), ShouldBeNil)
Convey("Then the channel has been deleted", func() {
_, err := GetChannel(db, c.ID)
So(err, ShouldNotBeNil)
})
})
Convey("When getting all channels for the channel-list", func() {
channels, err := GetChannelsForChannelList(db, cl.ID)
So(err, ShouldBeNil)
Convey("Then it contains the channel", func() {
So(channels, ShouldHaveLength, 1)
So(channels[0], ShouldResemble, c)
})
})
})
})
})
}
func TestCollectAndCallOnce(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a Redis connection pool", t, func() {
p := storage.NewRedisPool(conf.RedisURL)
c := p.Get()
_, err := c.Do("FLUSHALL")
So(err, ShouldBeNil)
c.Close()
Convey("Given a single LoRaWAN packet", func() {
phy := lorawan.PHYPayload{
MHDR: lorawan.MHDR{
MType: lorawan.UnconfirmedDataUp,
Major: lorawan.LoRaWANR1,
},
MIC: [4]byte{1, 2, 3, 4},
MACPayload: &lorawan.MACPayload{},
}
testTable := []struct {
Gateways []lorawan.EUI64
Count int
}{
{
[]lorawan.EUI64{
{1, 1, 1, 1, 1, 1, 1, 1},
},
1,
}, {
[]lorawan.EUI64{
{1, 1, 1, 1, 1, 1, 1, 1},
{2, 2, 2, 2, 2, 2, 2, 2},
},
2,
}, {
[]lorawan.EUI64{
{1, 1, 1, 1, 1, 1, 1, 1},
{2, 2, 2, 2, 2, 2, 2, 2},
{2, 2, 2, 2, 2, 2, 2, 2},
},
2,
},
}
for i, test := range testTable {
Convey(fmt.Sprintf("When running test %d, then %d packets are expected", i, test.Count), func() {
var received int
var called int
cb := func(packets RXPackets) error {
called = called + 1
received = len(packets)
return nil
}
var wg sync.WaitGroup
for _, gw := range test.Gateways {
wg.Add(1)
packet := models.RXPacket{
RXInfo: models.RXInfo{
MAC: gw,
},
PHYPayload: phy,
}
go func() {
err := collectAndCallOnce(p, packet, cb)
if err != nil {
t.Error(err)
}
wg.Done()
}()
}
wg.Wait()
So(called, ShouldEqual, 1)
So(received, ShouldEqual, test.Count)
})
}
})
})
}
func TestChannelListAndChannelAPI(t *testing.T) {
conf := common.GetTestConfig()
Convey("Given a clean database and api instances", t, func() {
db, err := storage.OpenDatabase(conf.PostgresDSN)
So(err, ShouldBeNil)
common.MustResetDB(db)
ctx := context.Background()
lsCtx := loraserver.Context{DB: db}
cAPI := NewChannelAPI(lsCtx)
clAPI := NewChannelListAPI(lsCtx)
Convey("When creating a channel-list", func() {
resp, err := clAPI.Create(ctx, &pb.CreateChannelListRequest{Name: "test channel-list"})
So(err, ShouldBeNil)
clID := resp.Id
Convey("Then the channel-list has been created", func() {
cl, err := clAPI.Get(ctx, &pb.GetChannelListRequest{Id: clID})
So(err, ShouldBeNil)
So(cl, ShouldResemble, &pb.GetChannelListResponse{Id: clID, Name: "test channel-list"})
})
Convey("When updating the channel-list", func() {
_, err := clAPI.Update(ctx, &pb.UpdateChannelListRequest{Id: clID, Name: "test channel-list changed"})
So(err, ShouldBeNil)
Convey("Then the channel-list has been updated", func() {
cl, err := clAPI.Get(ctx, &pb.GetChannelListRequest{Id: clID})
So(err, ShouldBeNil)
So(cl, ShouldResemble, &pb.GetChannelListResponse{Id: clID, Name: "test channel-list changed"})
})
})
Convey("Then listing the channel-lists returns 1 result", func() {
resp, err := clAPI.List(ctx, &pb.ListChannelListRequest{Limit: 10, Offset: 0})
So(err, ShouldBeNil)
So(resp.TotalCount, ShouldEqual, 1)
So(resp.Result, ShouldHaveLength, 1)
So(resp.Result[0], ShouldResemble, &pb.GetChannelListResponse{Id: clID, Name: "test channel-list"})
})
Convey("When deleting the channel-list", func() {
_, err := clAPI.Delete(ctx, &pb.DeleteChannelListRequest{Id: clID})
So(err, ShouldBeNil)
Convey("Then the channel-list has been deleted", func() {
resp, err := clAPI.List(ctx, &pb.ListChannelListRequest{Limit: 10, Offset: 0})
So(err, ShouldBeNil)
So(resp.TotalCount, ShouldEqual, 0)
})
})
Convey("When creating a channel", func() {
resp, err := cAPI.Create(ctx, &pb.CreateChannelRequest{
ChannelListID: clID,
Channel: 4,
Frequency: 868700000,
})
So(err, ShouldBeNil)
cID := resp.Id
Convey("Then the channel has been created", func() {
resp, err := cAPI.Get(ctx, &pb.GetChannelRequest{Id: cID})
So(err, ShouldBeNil)
So(resp, ShouldResemble, &pb.GetChannelResponse{
Id: cID,
ChannelListID: clID,
Channel: 4,
Frequency: 868700000,
})
Convey("When updating the channel", func() {
_, err := cAPI.Update(ctx, &pb.UpdateChannelRequest{
Id: cID,
ChannelListID: clID,
Channel: 5,
Frequency: 868700000,
})
So(err, ShouldBeNil)
Convey("Then the channel has been updated", func() {
resp, err := cAPI.Get(ctx, &pb.GetChannelRequest{Id: cID})
So(err, ShouldBeNil)
So(resp, ShouldResemble, &pb.GetChannelResponse{
Id: cID,
ChannelListID: clID,
Channel: 5,
Frequency: 868700000,
})
})
})
Convey("When deleting the channel", func() {
_, err := cAPI.Delete(ctx, &pb.DeleteChannelRequest{Id: cID})
So(err, ShouldBeNil)
Convey("Then the channel has been deleted", func() {
_, err := cAPI.Get(ctx, &pb.GetChannelRequest{Id: cID})
So(err, ShouldNotBeNil)
})
})
Convey("When getting all channels for the channel-list", func() {
resp, err := cAPI.ListByChannelList(ctx, &pb.ListChannelsByChannelListRequest{Id: clID})
So(err, ShouldBeNil)
Convey("Then it contains the channel", func() {
So(resp.Result, ShouldHaveLength, 1)
So(resp.Result[0], ShouldResemble, &pb.GetChannelResponse{
Id: cID,
ChannelListID: clID,
Channel: 4,
Frequency: 868700000,
})
})
})
})
})
})
})
}