// Create creates the given Node.
func (a *NodeAPI) Create(ctx context.Context, req *pb.CreateNodeRequest) (*pb.CreateNodeResponse, error) {
var appEUI, devEUI lorawan.EUI64
var appKey lorawan.AES128Key
if err := appEUI.UnmarshalText([]byte(req.AppEUI)); err != nil {
return nil, err
}
if err := devEUI.UnmarshalText([]byte(req.DevEUI)); err != nil {
return nil, err
}
if err := appKey.UnmarshalText([]byte(req.AppKey)); err != nil {
return nil, err
}
node := models.Node{
DevEUI: devEUI,
AppEUI: appEUI,
AppKey: appKey,
RXDelay: uint8(req.RxDelay),
RX1DROffset: uint8(req.Rx1DROffset),
}
if req.ChannelListID > 0 {
node.ChannelListID = &req.ChannelListID
}
if err := storage.CreateNode(a.ctx.DB, node); err != nil {
return nil, err
}
return &pb.CreateNodeResponse{}, nil
}
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 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)
})
})
})
})
})
})
}