Ejemplo n.º 1
0
func TestGetDistinct(t *testing.T) {
	commonUUID := common.NewUUID()
	msg1 := &common.SmapMessage{Path: "/sensor1", UUID: common.NewUUID(), Metadata: common.Dict{"Tag": "Value1", "Shared": string(commonUUID)}}
	msg2 := &common.SmapMessage{Path: "/sensor2", UUID: common.NewUUID(), Metadata: common.Dict{"Tag": "Value2", "Shared": string(commonUUID)}}
	ms.SaveTags(msg1)
	ms.SaveTags(msg2)
	for _, test := range []struct {
		tag    string
		where  bson.M
		result []string
	}{
		{
			"Metadata.Tag",
			bson.M{"Metadata.Shared": commonUUID},
			[]string{"Value1", "Value2"},
		},
	} {
		res, err := ms.GetDistinct(test.tag, test.where)
		if err != nil {
			t.Errorf("Err during GetDistinct (%v) \n%v", err, test)
		}
		for i := 0; i < len(test.result); i++ {
			if !reflect.DeepEqual(res[i], test.result[i]) {
				t.Errorf("Result should be \n%v\n but was \n%v\n", test.result[i], res[i])
			}
		}
	}
}
Ejemplo n.º 2
0
func TestGetUUIDs(t *testing.T) {
	commonUUID := common.NewUUID()
	msg1 := &common.SmapMessage{Path: "/sensor1", UUID: common.NewUUID(), Metadata: common.Dict{"Tag": "Value1", "Shared": string(commonUUID)}}
	msg2 := &common.SmapMessage{Path: "/sensor2", UUID: common.NewUUID(), Metadata: common.Dict{"Tag": "Value2", "Shared": string(commonUUID)}}
	ms.SaveTags(msg1)
	ms.SaveTags(msg2)

	results, err := ms.GetUUIDs(bson.M{"Metadata.Shared": string(commonUUID)})

	if err != nil {
		t.Errorf("Error running GetUUIDs (%v)", err)
		return
	}

	if len(results) != 2 {
		t.Errorf("Should have returned 2, but returned %v", len(results))
		return
	}

	if !((results[0] == msg1.UUID || results[1] == msg1.UUID) &&
		(results[0] == msg2.UUID || results[1] == msg2.UUID)) {
		t.Errorf("Results were %v but should be %v", results, []common.UUID{msg1.UUID, msg2.UUID})

	}
}
Ejemplo n.º 3
0
func TestGetTags(t *testing.T) {
	myUUID := common.NewUUID()
	myPath := "/sensor8"
	for _, test := range []struct {
		msg    *common.SmapMessage
		tags   []string
		where  bson.M
		result common.SmapMessageList
	}{
		{
			&common.SmapMessage{Path: myPath, UUID: myUUID},
			[]string{"uuid"},
			bson.M{"uuid": myUUID},
			common.SmapMessageList{{UUID: myUUID}},
		},
		{
			&common.SmapMessage{Path: myPath, UUID: myUUID, Metadata: common.Dict{"System": "HVAC", "Point|Name": "My Point"}},
			[]string{"Metadata.System", "Path"},
			bson.M{"uuid": myUUID},
			common.SmapMessageList{{Path: myPath, Metadata: common.Dict{"System": "HVAC"}}},
		},
	} {
		ms.SaveTags(test.msg)
		res, err := ms.GetTags(test.tags, test.where)
		if err != nil {
			t.Errorf("Err during GetTags (%v) \n%v", err, test)
		}
		if !reflect.DeepEqual(test.result, res) {
			t.Errorf("Result should be \n%v\n but was \n%v\n", test.result.ToBson(), res.ToBson())
		}
	}
}
Ejemplo n.º 4
0
func BenchmarkSaveTagsBare(b *testing.B) {
	for i := 0; i < b.N; i++ {
		msg := &common.SmapMessage{
			Path: "/sensor8",
			UUID: common.NewUUID(),
		}
		ms.SaveTags(msg)
	}
}
Ejemplo n.º 5
0
func BenchmarkSaveTagsBareParallel(b *testing.B) {
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			msg := &common.SmapMessage{
				Path: "/sensor8",
				UUID: common.NewUUID(),
			}
			ms.SaveTags(msg)
		}
	})
}
Ejemplo n.º 6
0
func BenchmarkSaveTagsWithMetadata(b *testing.B) {
	msg := &common.SmapMessage{
		Path: "/sensor8",
		UUID: common.NewUUID(),
		Metadata: common.Dict{
			"System":     "HVAC",
			"Point.Name": "My Point",
		},
	}
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ms.SaveTags(msg)
	}
}
Ejemplo n.º 7
0
func BenchmarkGetUnitOfTime(b *testing.B) {
	msg := &common.SmapMessage{
		Path: "/sensor8",
		UUID: common.NewUUID(),
		Properties: &common.SmapProperties{
			UnitOfTime:    common.UOT_MS,
			StreamType:    common.NUMERIC_STREAM,
			UnitOfMeasure: "F",
		},
	}
	ms.SaveTags(msg)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ms.GetUnitOfTime(msg.UUID)
	}
}
Ejemplo n.º 8
0
func BenchmarkSaveTagsWithMetadataParallel(b *testing.B) {
	msg := &common.SmapMessage{
		Path: "/sensor8",
		UUID: common.NewUUID(),
		Metadata: common.Dict{
			"System":     "HVAC",
			"Point.Name": "My Point",
		},
	}
	b.ReportAllocs()
	b.ResetTimer()
	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			ms.SaveTags(msg)
		}
	})
}
Ejemplo n.º 9
0
func BenchmarkGetTags(b *testing.B) {
	msg := &common.SmapMessage{
		Path: "/sensor8",
		UUID: common.NewUUID(),
		Metadata: common.Dict{
			"System":     "HVAC",
			"Point.Name": "My Point",
		},
	}
	tags := []string{"uuid"}
	where := bson.M{"uuid": msg.UUID}
	ms.SaveTags(msg)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ms.GetTags(tags, where)
	}
}
Ejemplo n.º 10
0
func TestGetUnitOfMeasure(t *testing.T) {
	msg := &common.SmapMessage{
		Path: "/sensor8",
		UUID: common.NewUUID(),
		Properties: &common.SmapProperties{
			UnitOfTime:    common.UOT_MS,
			StreamType:    common.NUMERIC_STREAM,
			UnitOfMeasure: "F",
		},
	}
	ms.SaveTags(msg)

	uom, err := ms.GetUnitOfMeasure(msg.UUID)
	if err != nil {
		t.Errorf("Err getting UnitofMeasure for %v (%v)", msg, err)
	}
	if uom != "F" {
		t.Errorf("UOT should be %v but was %v", "F", uom)
	}
}
Ejemplo n.º 11
0
func BenchmarkArchiverAddNoMetadata(b *testing.B) {
	msg := &common.SmapMessage{
		UUID: common.NewUUID(),
		Properties: &common.SmapProperties{
			UnitOfTime:    common.UOT_NS,
			UnitOfMeasure: "unit",
			StreamType:    common.NUMERIC_STREAM,
		},
		Readings: make([]common.Reading, 1),
	}
	ek := common.NewEphemeralKey()
	rdg := &common.SmapNumberReading{Time: 0, Value: 0}
	msg.Readings[0] = rdg
	offset := time.Now().UnixNano()
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		rdg.Time = uint64(offset + int64(i))
		msg.Readings[0] = rdg
		testArchiver.AddData(msg, ek)
		msg.Properties = nil
	}

}
Ejemplo n.º 12
0
func TestHandleAdd(t *testing.T) {
	aConfig := giles.LoadConfig("../giles.cfg")
	testArchiver = giles.NewArchiver(aConfig)
	h := NewHTTPHandler(testArchiver)
	uuid := common.NewUUID()

	for _, test := range []struct {
		title          string
		toPost         string
		expectedStatus int
		expectedBody   string
	}{
		{
			"No Readings",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v" }}`, uuid),
			200,
			"",
		},
		{
			"Empty Readings 1",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Readings": [ ]}}`, uuid),
			200,
			"",
		},
		{
			"Empty Readings 2",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Readings": [[ ]]}}`, uuid),
			200,
			"",
		},
		{
			"Bad JSON 1",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Readings": [ ]]}}`, uuid),
			400,
			"invalid character ']' after object key:value pair",
		},
		{
			"Bad JSON 2",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Readings": [[ ]]}`, uuid),
			400,
			"unexpected EOF",
		},
		{
			"Bad Readings 1: negative timestamp",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Readings": [[-1, 0]]}}`, uuid),
			400,
			"json: cannot unmarshal number -1 into Go value of type uint64",
		},
		{
			"Bad Readings 2: too big timestamp",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Readings": [[1000000000000000000, 0]]}}`, uuid),
			500,
			"Bad Timestamp: 1000000000000000000",
		},
		{
			"Bad Readings 3: too big timestamp",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Readings": [[3458764513820540929, 0]]}}`, uuid),
			500,
			"Bad Timestamp: 3458764513820540929",
		},
		{
			"Good readings: 1 reading max timestamp",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Properties": {"UnitofTime": "ns"}, "Readings": [[3458764513820540928, 0]]}}`, uuid),
			200,
			"",
		},
		{
			"Good readings: 2 repeat readings",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Properties": {"UnitofTime": "ns"}, "Readings": [[1000000000000000000, 0], [1000000000000000000, 0]]}}`, uuid),
			200,
			"",
		},
		{
			"Good readings: 2 repeat readings diff values",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Properties": {"UnitofTime": "ns"}, "Readings": [[2000000000000000000, 0], [2000000000000000000, 1]]}}`, uuid),
			200,
			"",
		},
		{
			"Lots of readings",
			fmt.Sprintf(`{"/sensor/0": {"Path": "/sensor/0", "uuid": "%v", "Properties": {"UnitofTime": "ns"}, "Readings": [ %v [1000000000000000000, 0]]}}`, uuid, strings.Repeat("[1000000000000000000, 0],", 1000)),
			200,
			"",
		},
	} {

		testflight.WithServer(h.handler, func(r *testflight.Requester) {
			response := r.Post("/add/dummykey", testflight.JSON, test.toPost)
			assert.Equal(t, test.expectedStatus, response.StatusCode, test.title)
			assert.Equal(t, test.expectedBody, response.Body, test.title)
		})
	}
}