github.com/simpleiot/simpleiot@v0.18.3/store/store_test.go (about)

     1  package store_test
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/google/uuid"
     9  	"github.com/nats-io/nats.go"
    10  	"github.com/simpleiot/simpleiot/client"
    11  	"github.com/simpleiot/simpleiot/data"
    12  	"github.com/simpleiot/simpleiot/server"
    13  )
    14  
    15  func TestStoreSimple(t *testing.T) {
    16  	_, _, stop, err := server.TestServer()
    17  
    18  	if err != nil {
    19  		t.Fatal("Error starting test server: ", err)
    20  	}
    21  
    22  	defer stop()
    23  }
    24  
    25  func TestStoreUp(t *testing.T) {
    26  	nc, root, stop, err := server.TestServer()
    27  	_ = root
    28  
    29  	if err != nil {
    30  		t.Fatal("Error starting test server: ", err)
    31  	}
    32  
    33  	defer stop()
    34  
    35  	chUpPoints := make(chan data.Points)
    36  
    37  	sub, err := nc.Subscribe("up.root.>", func(msg *nats.Msg) {
    38  		points, err := data.PbDecodePoints(msg.Data)
    39  		if err != nil {
    40  			fmt.Println("Error decoding points")
    41  			return
    42  		}
    43  
    44  		chUpPoints <- points
    45  	})
    46  
    47  	if err != nil {
    48  		t.Fatal("sub error: ", err)
    49  	}
    50  
    51  	defer func() {
    52  		_ = sub.Unsubscribe()
    53  	}()
    54  
    55  	err = client.SendNodePoint(nc, root.ID, data.Point{Type: data.PointTypeDescription,
    56  		Text: "rootly"}, false)
    57  
    58  	if err != nil {
    59  		t.Fatal("Error sending point: ", err)
    60  	}
    61  
    62  stopFor:
    63  	for {
    64  		select {
    65  		case <-time.After(time.Second):
    66  			t.Fatal("Timeout waiting for description change")
    67  		case p := <-chUpPoints:
    68  			if p[0].Type != data.PointTypeDescription {
    69  				continue
    70  			}
    71  			break stopFor // all is well
    72  		}
    73  	}
    74  }
    75  
    76  func TestStoreMultiplePoints(t *testing.T) {
    77  	nc, root, stop, err := server.TestServer()
    78  	_ = nc
    79  	_ = root
    80  
    81  	if err != nil {
    82  		t.Fatal("Error starting test server: ", err)
    83  	}
    84  
    85  	defer stop()
    86  
    87  	// add client node
    88  	u := client.User{
    89  		ID:        uuid.New().String(),
    90  		Parent:    root.ID,
    91  		FirstName: "cliff",
    92  		LastName:  "brake",
    93  	}
    94  
    95  	err = client.SendNodeType(nc, u, "test")
    96  	if err != nil {
    97  		t.Fatal("Error sending node: ", err)
    98  	}
    99  
   100  	// set up watcher for node
   101  	getNode, stopWatcher, err := client.NodeWatcher[client.User](nc, u.ID, u.Parent)
   102  	if err != nil {
   103  		t.Fatal("Error setting up node watcher")
   104  	}
   105  
   106  	defer stopWatcher()
   107  
   108  	// wait for node to be populated
   109  	start := time.Now()
   110  	for {
   111  		cur := getNode()
   112  		if cur.ID == u.ID {
   113  			break
   114  		}
   115  		if time.Since(start) > time.Second {
   116  			t.Fatal("Timeout waiting for user node")
   117  		}
   118  		<-time.After(time.Millisecond * 10)
   119  	}
   120  
   121  	err = client.SendNodePoints(nc, u.ID, data.Points{
   122  		{Type: data.PointTypeFirstName, Text: "Cliff"},
   123  		{Type: data.PointTypeLastName, Text: "Brake"},
   124  	}, true)
   125  
   126  	if err != nil {
   127  		t.Fatal("send points failed: ", err)
   128  	}
   129  
   130  	time.Sleep(time.Millisecond * 10)
   131  	updated := getNode()
   132  
   133  	if updated.FirstName != "Cliff" {
   134  		t.Fatal("first name not updated: ", updated.FirstName)
   135  	}
   136  
   137  	if updated.LastName != "Brake" {
   138  		t.Fatal("last name not updated: ", updated.LastName)
   139  	}
   140  }
   141  
   142  func TestGetNatsURI(t *testing.T) {
   143  	nc, root, stop, err := server.TestServer()
   144  	_ = nc
   145  	_ = root
   146  
   147  	if err != nil {
   148  		t.Fatal("Error starting test server: ", err)
   149  	}
   150  
   151  	defer stop()
   152  
   153  	uri, _, err := client.GetNatsURI(nc)
   154  
   155  	if err != nil {
   156  		t.Fatal(err)
   157  	}
   158  
   159  	if uri != server.TestServerOptions.NatsServer {
   160  		t.Fatal("Did not get expected URI: ", uri)
   161  	}
   162  }
   163  
   164  func TestDontAllowDeleteRootNode(t *testing.T) {
   165  	nc, root, stop, err := server.TestServer()
   166  	_ = root
   167  
   168  	if err != nil {
   169  		t.Fatal("Error starting test server: ", err)
   170  	}
   171  
   172  	defer stop()
   173  
   174  	err = client.SendEdgePoint(nc, root.ID, "root", data.Point{Type: data.PointTypeTombstone,
   175  		Value: 1}, true)
   176  
   177  	if err == nil {
   178  		t.Fatal("sending edge point should have returned an error")
   179  	}
   180  
   181  	nodes, err := client.GetNodes(nc, "root", root.ID, "", false)
   182  
   183  	if err != nil {
   184  		t.Fatal("Error getting node: ", err)
   185  	}
   186  
   187  	if len(nodes) < 1 {
   188  		t.Fatal("Root node was deleted")
   189  	}
   190  }