Add TimeoutMatcher with tests

TimeoutMatcher is a Matcher interface implementation for handling
running requests timeouts caused by expiration of requests' job timeout.

It tries to run Close on all reported requests. Some of the timeouts
might be invalid, because the request has changed it's state to done
or failed.

Tests base on using MockRequestsManager for mocking up RequestsManager
interface.

Change-Id: I6540ab50eb84f8ab1b9737ad71e7ae3a5ddd3170
Signed-off-by: Lukasz Wojciechowski <l.wojciechow@partner.samsung.com>

diff --git a/matcher/timeoutmatcher.go b/matcher/timeoutmatcher.go
new file mode 100644 (file)
index 0000000..c4c6809
--- /dev/null
+++ b/matcher/timeoutmatcher.go
@@ -0,0 +1,50 @@
+/*
+ *  Copyright (c) 2017-2018 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
+ */
+
+// File matcher/timeoutmatcher.go provides TimeoutMatcher structure.
+// It implements Matcher interface and it should be used for handling timeout
+// events caused by expiration of requests' job timeout.
+
+package matcher
+
+import (
+       . "git.tizen.org/tools/boruta"
+)
+
+// TimeoutMatcher implements Matcher interface for handling running requests
+// timeout.
+type TimeoutMatcher struct {
+       Matcher
+       // requests provides internal boruta access to requests.
+       requests RequestsManager
+}
+
+// NewTimeoutMatcher creates a new TimeoutMatcher structure.
+func NewTimeoutMatcher(r RequestsManager) *TimeoutMatcher {
+       return &TimeoutMatcher{
+               requests: r,
+       }
+}
+
+// Notify implements Matcher interface. This method reacts to events passed to
+// matcher. Close method is called on RequestsManager for each request.
+// Some of the cases might be invalid, because the request's state has been changed
+// to DONE or FAILED. Verification of closing conditions is done inside Close method.
+func (m TimeoutMatcher) Notify(out []ReqID) {
+       for _, r := range out {
+               m.requests.Close(r)
+       }
+}

diff --git a/matcher/timeoutmatcher_test.go b/matcher/timeoutmatcher_test.go
new file mode 100644 (file)
index 0000000..9126457
--- /dev/null
+++ b/matcher/timeoutmatcher_test.go
@@ -0,0 +1,65 @@
+/*
+ *  Copyright (c) 2017-2018 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 matcher
+
+import (
+       . "git.tizen.org/tools/boruta"
+
+       gomock "github.com/golang/mock/gomock"
+       . "github.com/onsi/ginkgo"
+       . "github.com/onsi/gomega"
+)
+
+var _ = Describe("TimeoutMatcher", func() {
+       var ctrl *gomock.Controller
+       var r *MockRequestsManager
+       var m Matcher
+
+       BeforeEach(func() {
+               ctrl = gomock.NewController(GinkgoT())
+               r = NewMockRequestsManager(ctrl)
+               m = NewTimeoutMatcher(r)
+       })
+       AfterEach(func() {
+               ctrl.Finish()
+       })
+       Describe("NewTimeoutMatcher", func() {
+               It("should create a new TimeoutMatcher", func() {
+                       Expect(m).NotTo(BeNil())
+               })
+       })
+       Describe("Notify", func() {
+               It("should not call any methods on empty requests", func() {
+                       reqs := make([]ReqID, 0)
+
+                       m.Notify(reqs)
+               })
+               It("should run Close for each reqID passed to Notify and ignore returned errors", func() {
+                       err := NotFoundError("Request")
+                       reqs := []ReqID{1, 2, 5, 7}
+
+                       gomock.InOrder(
+                               r.EXPECT().Close(reqs[0]).Return(err),
+                               r.EXPECT().Close(reqs[1]).Return(nil),
+                               r.EXPECT().Close(reqs[2]).Return(nil),
+                               r.EXPECT().Close(reqs[3]).Return(err),
+                       )
+
+                       m.Notify(reqs)
+               })
+       })
+})