Add benchmark tests for WorkerList

Change-Id: Ic92c9d6e23a55971edd1c9ad2d15c939c8a4dba6
Signed-off-by: Aleksander Mistewicz <a.mistewicz@samsung.com>
Reviewed-on: https://mcdsrvbld02.digital.local/review/49120
Reviewed-by: Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
Tested-by: Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>
Reviewed-by: Maciej Wereski <m.wereski@partner.samsung.com>
Tested-by: Maciej Wereski <m.wereski@partner.samsung.com>

diff --git a/workers/workers_test.go b/workers/workers_test.go
new file mode 100644 (file)
index 0000000..0c0f902
--- /dev/null
+++ b/workers/workers_test.go
@@ -0,0 +1,108 @@
+/*
+ *  Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License
+ */
+
+package workers_test
+
+import (
+       "math/rand"
+
+       "git.tizen.org/tools/boruta"
+       "git.tizen.org/tools/boruta/workers"
+
+       . "github.com/onsi/ginkgo"
+       . "github.com/onsi/gomega"
+       "github.com/satori/go.uuid"
+)
+
+var _ = Describe("WorkerList", func() {
+       var wl *workers.WorkerList
+       BeforeEach(func() {
+               wl = workers.NewWorkerList()
+       })
+
+       getRandomCaps := func() boruta.Capabilities {
+               return map[string]string{
+                       workers.UUID: uuid.NewV4().String(),
+               }
+       }
+
+       Measure("it should be fast", func(b Benchmarker) {
+               maximumWorkers := 1024
+               maximumCaps := maximumWorkers / 16
+               maximumGroups := maximumWorkers / 4
+               matchingCaps := "TestCaps"
+               caps := make([]boruta.Capabilities, maximumWorkers)
+               for i := 0; i < maximumWorkers; i++ {
+                       caps[i] = getRandomCaps()
+                       caps[i][matchingCaps] = string(i % maximumCaps)
+               }
+               b.Time("register", func() {
+                       for i := 0; i < maximumWorkers; i++ {
+                               err := wl.Register(caps[i])
+                               Expect(err).ToNot(HaveOccurred())
+                       }
+               })
+               for i := 0; i < maximumWorkers; i++ {
+                       err := wl.SetGroups(boruta.WorkerUUID(caps[i][workers.UUID]),
+                               boruta.Groups{
+                                       "TestGroup",
+                                       boruta.Group(i % (maximumGroups / 2)),
+                                       boruta.Group(i % maximumGroups),
+                               })
+                       Expect(err).ToNot(HaveOccurred())
+               }
+               maximumListTests := maximumGroups + maximumCaps
+               groupWithCaps := make([]boruta.Groups, maximumListTests)
+               for v := 0; v < maximumListTests; v++ {
+                       groupWithCaps[v] = boruta.Groups{
+                               boruta.Group(rand.Intn(maximumGroups)),
+                               boruta.Group(rand.Intn(maximumCaps)),
+                       }
+               }
+               b.Time("list all", func() {
+                       for i := 0; i < maximumListTests; i++ {
+                               _, err := wl.ListWorkers(nil, nil)
+                               Expect(err).ToNot(HaveOccurred())
+                       }
+               })
+               b.Time("list with caps matching", func() {
+                       for i := 0; i < maximumListTests; i++ {
+                               _, err := wl.ListWorkers(nil,
+                                       boruta.Capabilities{matchingCaps: string(groupWithCaps[i][1])})
+                               Expect(err).ToNot(HaveOccurred())
+                       }
+               })
+               b.Time("list with groups matching", func() {
+                       for i := 0; i < maximumListTests; i++ {
+                               _, err := wl.ListWorkers(boruta.Groups{boruta.Group(groupWithCaps[i][0])}, nil)
+                               Expect(err).ToNot(HaveOccurred())
+                       }
+               })
+               b.Time("list with both groups and caps matching", func() {
+                       for i := 0; i < maximumListTests; i++ {
+                               _, err := wl.ListWorkers(boruta.Groups{boruta.Group(groupWithCaps[i][0])},
+                                       boruta.Capabilities{matchingCaps: string(groupWithCaps[i][1])})
+                               Expect(err).ToNot(HaveOccurred())
+                       }
+               })
+               b.Time("deregister", func() {
+                       for i := 0; i < maximumWorkers; i++ {
+                               err := wl.Deregister(boruta.WorkerUUID(caps[i][workers.UUID]))
+                               Expect(err).ToNot(HaveOccurred())
+                       }
+               })
+       }, 2)
+})