Tests for SendRemoteCommand[Cached]

socketserver/server/backend_test.go

@@ -3,10 +3,14 @@ package server
 import (
 	"net/url"
 	"testing"
+	"net/http"
+	. "gopkg.in/check.v1"
 )
 
+func Test(t *testing.T) { TestingT(t) }
+
 func TestSealRequest(t *testing.T) {
-	TSetup(0, nil)
+	TSetup(SetupNoServers, nil)
 
 	values := url.Values{
 		"QuickBrownFox": []string{"LazyDog"},
@@ -29,6 +33,95 @@ func TestSealRequest(t *testing.T) {
 	}
 }
 
-func TestSendRemoteCommand(t *testing.T) {
+type BackendSuite struct{}
+var _ = Suite(&BackendSuite{})
 
+func (s *BackendSuite) TestSendRemoteCommand(c *C) {
+	const TestCommand1 = "somecommand"
+	const TestCommand2 = "other"
+	const PathTestCommand1 = "/cmd/" + TestCommand1
+	const PathTestCommand2 = "/cmd/" + TestCommand2
+	const TestData1 = "623478.32"
+	const TestData2 = "\"Hello, there\""
+	const TestData3 = "3"
+	const TestUsername = "sirstendec"
+	const TestResponse1 = "asfdg"
+	const TestResponse2 = "yuiop"
+	const TestErrorText = "{\"err\":\"some kind of special error\"}"
+
+	var AnonAuthInfo = AuthInfo{}
+	var NonValidatedAuthInfo = AuthInfo{TwitchUsername: TestUsername}
+	var ValidatedAuthInfo = AuthInfo{TwitchUsername: TestUsername, UsernameValidated: true}
+
+	headersCacheTwoSeconds := http.Header{"FFZ-Cache": []string{"2"}}
+	headersCacheInvalid := http.Header{"FFZ-Cache": []string{"NotANumber"}}
+	headersApplicationJson := http.Header{"Content-Type": []string{"application/json"}}
+
+	backend := NewTBackendRequestChecker(c,
+		TExpectedBackendRequest{200, PathTestCommand1, &url.Values{"clientData": []string{TestData1}, "usernameClaimed": []string{""}}, TestResponse1, nil},
+		TExpectedBackendRequest{200, PathTestCommand1, &url.Values{"clientData": []string{TestData1}, "usernameClaimed": []string{""}}, TestResponse2, nil},
+		TExpectedBackendRequest{200, PathTestCommand1, &url.Values{"clientData": []string{TestData1}, "usernameClaimed": []string{TestUsername}}, TestResponse1, nil},
+		TExpectedBackendRequest{200, PathTestCommand1, &url.Values{"clientData": []string{TestData1}, "usernameVerified": []string{TestUsername}}, TestResponse1, nil},
+		TExpectedBackendRequest{200, PathTestCommand2, &url.Values{"clientData": []string{TestData2}, "usernameClaimed": []string{TestUsername}}, TestResponse1, headersCacheTwoSeconds},
+		// cached
+		// cached
+		TExpectedBackendRequest{200, PathTestCommand2, &url.Values{"clientData": []string{TestData1}, "usernameClaimed": []string{TestUsername}}, TestResponse2, headersCacheTwoSeconds},
+		TExpectedBackendRequest{401, PathTestCommand1, &url.Values{"clientData": []string{TestData1}, "usernameClaimed": []string{TestUsername}}, "", nil},
+		TExpectedBackendRequest{503, PathTestCommand1, &url.Values{"clientData": []string{TestData1}, "usernameClaimed": []string{TestUsername}}, "", nil},
+		TExpectedBackendRequest{418, PathTestCommand1, &url.Values{"clientData": []string{TestData1}, "usernameClaimed": []string{TestUsername}}, TestErrorText, headersApplicationJson},
+		TExpectedBackendRequest{200, PathTestCommand2, &url.Values{"clientData": []string{TestData3}, "usernameClaimed": []string{TestUsername}}, TestResponse1, headersCacheInvalid},
+	)
+	_, _, _ = TSetup(SetupWantBackendServer, backend)
+	defer backend.Close()
+
+	var resp string
+	var err error
+
+	resp, err = SendRemoteCommand(TestCommand1, TestData1, AnonAuthInfo)
+	c.Check(resp, Equals, TestResponse1)
+	c.Check(err, IsNil)
+
+	resp, err = SendRemoteCommand(TestCommand1, TestData1, AnonAuthInfo)
+	c.Check(resp, Equals, TestResponse2)
+	c.Check(err, IsNil)
+
+	resp, err = SendRemoteCommand(TestCommand1, TestData1, NonValidatedAuthInfo)
+	c.Check(resp, Equals, TestResponse1)
+	c.Check(err, IsNil)
+
+	resp, err = SendRemoteCommand(TestCommand1, TestData1, ValidatedAuthInfo)
+	c.Check(resp, Equals, TestResponse1)
+	c.Check(err, IsNil)
+	// cache save
+	resp, err = SendRemoteCommandCached(TestCommand2, TestData2, NonValidatedAuthInfo)
+	c.Check(resp, Equals, TestResponse1)
+	c.Check(err, IsNil)
+
+	resp, err = SendRemoteCommandCached(TestCommand2, TestData2, NonValidatedAuthInfo) // cache hit
+	c.Check(resp, Equals, TestResponse1)
+	c.Check(err, IsNil)
+
+	resp, err = SendRemoteCommandCached(TestCommand2, TestData2, AnonAuthInfo) // cache hit
+	c.Check(resp, Equals, TestResponse1)
+	c.Check(err, IsNil)
+	// cache miss - data is different
+	resp, err = SendRemoteCommandCached(TestCommand2, TestData1, NonValidatedAuthInfo)
+	c.Check(resp, Equals, TestResponse2)
+	c.Check(err, IsNil)
+
+	resp, err = SendRemoteCommand(TestCommand1, TestData1, NonValidatedAuthInfo)
+	c.Check(resp, Equals, "")
+	c.Check(err, Equals, ErrAuthorizationNeeded)
+
+	resp, err = SendRemoteCommand(TestCommand1, TestData1, NonValidatedAuthInfo)
+	c.Check(resp, Equals, "")
+	c.Check(err, ErrorMatches, "backend http error: 503")
+
+	resp, err = SendRemoteCommand(TestCommand1, TestData1, NonValidatedAuthInfo)
+	c.Check(resp, Equals, "")
+	c.Check(err, ErrorMatches, TestErrorText)
+
+	resp, err = SendRemoteCommand(TestCommand2, TestData3, NonValidatedAuthInfo)
+	c.Check(resp, Equals, "")
+	c.Check(err, ErrorMatches, "The RPC server returned a non-integer cache duration: .*")
 }

socketserver/server/subscriptions_test.go

@@ -37,10 +37,10 @@ func TestSubscriptionAndPublish(t *testing.T) {
 	var urls TURLs
 
 	var backendExpected = NewTBackendRequestChecker(t,
-		TExpectedBackendRequest{200, bPathAnnounceStartup, &url.Values{"startup": []string{"1"}}, ""},
+		TExpectedBackendRequest{200, bPathAnnounceStartup, &url.Values{"startup": []string{"1"}}, "", nil},
-		TExpectedBackendRequest{200, bPathAddTopic, &url.Values{"channels": []string{TestChannelName1}, "added": []string{"t"}}, "ok"},
+		TExpectedBackendRequest{200, bPathAddTopic, &url.Values{"channels": []string{TestChannelName1}, "added": []string{"t"}}, "ok", nil},
-		TExpectedBackendRequest{200, bPathAddTopic, &url.Values{"channels": []string{TestChannelName2}, "added": []string{"t"}}, "ok"},
+		TExpectedBackendRequest{200, bPathAddTopic, &url.Values{"channels": []string{TestChannelName2}, "added": []string{"t"}}, "ok", nil},
-		TExpectedBackendRequest{200, bPathAddTopic, &url.Values{"channels": []string{TestChannelName3}, "added": []string{"t"}}, "ok"},
+		TExpectedBackendRequest{200, bPathAddTopic, &url.Values{"channels": []string{TestChannelName3}, "added": []string{"t"}}, "ok", nil},
 	)
 	server, _, urls = TSetup(SetupWantSocketServer|SetupWantBackendServer|SetupWantURLs, backendExpected)
 
@@ -242,10 +242,10 @@ func TestRestrictedCommands(t *testing.T) {
 	var urls TURLs
 
 	var backendExpected = NewTBackendRequestChecker(t,
-		TExpectedBackendRequest{200, bPathAnnounceStartup, &url.Values{"startup": []string{"1"}}, ""},
+		TExpectedBackendRequest{200, bPathAnnounceStartup, &url.Values{"startup": []string{"1"}}, "", nil},
-		TExpectedBackendRequest{401, fmt.Sprintf("%s%s", bPathOtherCommand, TestCommandNeedsAuth), &url.Values{"usernameClaimed": []string{""}, "clientData": []string{TestRequestDataJSON}}, ""},
+		TExpectedBackendRequest{401, fmt.Sprintf("%s%s", bPathOtherCommand, TestCommandNeedsAuth), &url.Values{"usernameClaimed": []string{""}, "clientData": []string{TestRequestDataJSON}}, "", nil},
-		TExpectedBackendRequest{401, fmt.Sprintf("%s%s", bPathOtherCommand, TestCommandNeedsAuth), &url.Values{"usernameClaimed": []string{TestUsername}, "clientData": []string{TestRequestDataJSON}}, ""},
+		TExpectedBackendRequest{401, fmt.Sprintf("%s%s", bPathOtherCommand, TestCommandNeedsAuth), &url.Values{"usernameClaimed": []string{TestUsername}, "clientData": []string{TestRequestDataJSON}}, "", nil},
-		TExpectedBackendRequest{200, fmt.Sprintf("%s%s", bPathOtherCommand, TestCommandNeedsAuth), &url.Values{"usernameVerified": []string{TestUsername}, "clientData": []string{TestRequestDataJSON}}, fmt.Sprintf("\"%s\"", TestReplyData)},
+		TExpectedBackendRequest{200, fmt.Sprintf("%s%s", bPathOtherCommand, TestCommandNeedsAuth), &url.Values{"usernameVerified": []string{TestUsername}, "clientData": []string{TestRequestDataJSON}}, fmt.Sprintf("\"%s\"", TestReplyData), nil},
 	)
 	server, _, urls = TSetup(SetupWantSocketServer|SetupWantBackendServer|SetupWantURLs, backendExpected)
 

socketserver/server/testinfra_test.go

@@ -18,6 +18,7 @@ const (
 	SetupWantBackendServer
 	SetupWantURLs
 )
+const SetupNoServers = 0
 
 func TSetup(flags int, backendChecker *TBackendRequestChecker) (socketserver *httptest.Server, backend *httptest.Server, urls TURLs) {
 	DumpBacklogData()
@@ -66,14 +67,20 @@ func TSetup(flags int, backendChecker *TBackendRequestChecker) (socketserver *ht
 	return
 }
 
+type TBC interface {
+	Error(args ...interface{})
+	Errorf(format string, args ...interface{})
+}
+
 const MethodIsPost = "POST"
 
 type TExpectedBackendRequest struct {
 	ResponseCode int
 	Path         string
 	// Method       string // always POST
-	PostForm *url.Values
+	PostForm        *url.Values
-	Response string
+	Response        string
+	ResponseHeaders http.Header
 }
 
 func (er *TExpectedBackendRequest) String() string {
@@ -87,10 +94,10 @@ type TBackendRequestChecker struct {
 	ExpectedRequests []TExpectedBackendRequest
 
 	currentRequest int
-	tb             testing.TB
+	tb             TBC
 }
 
-func NewTBackendRequestChecker(tb testing.TB, urls ...TExpectedBackendRequest) *TBackendRequestChecker {
+func NewTBackendRequestChecker(tb TBC, urls ...TExpectedBackendRequest) *TBackendRequestChecker {
 	return &TBackendRequestChecker{ExpectedRequests: urls, tb: tb, currentRequest: 0}
 }
 
@@ -115,6 +122,17 @@ func (backend *TBackendRequestChecker) ServeHTTP(w http.ResponseWriter, r *http.
 	cur := backend.ExpectedRequests[backend.currentRequest]
 	backend.currentRequest++
 
+	headers := w.Header()
+	for k, v := range cur.ResponseHeaders {
+		if len(v) == 1 {
+			headers.Set(k, v[0])
+		} else if len(v) == 0 {
+			headers.Del(k)
+		} else {
+			for _, hv := range v { headers.Add(k, hv) }
+		}
+	}
+
 	defer func() {
 		w.WriteHeader(cur.ResponseCode)
 		if cur.Response != "" {
@@ -144,7 +162,7 @@ func (backend *TBackendRequestChecker) Close() error {
 	return nil
 }
 
-func TcompareForms(tb testing.TB, ctx string, expectedForm, gotForm url.Values) (anyErrors bool) {
+func TcompareForms(tb TBC, ctx string, expectedForm, gotForm url.Values) (anyErrors bool) {
 	for k, expVal := range expectedForm {
 		gotVal, ok := gotForm[k]
 		if !ok {