service/taskqueue: Add NewPOSTTask, remove NewTask

impl/memory/taskqueue_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package memory
 
 import (
         "fmt"
         "math/rand"
         "net/http"
@@ skipping 21 matching lines @@
                 c = Use(c)
 
                 tq := tqS.Get(c)
                 tqt := tq.Testable()
                 So(tqt, ShouldNotBeNil)
 
                 So(tq, ShouldNotBeNil)
 
                 Convey("implements TQMultiReadWriter", func() {
                         Convey("Add", func() {
-                                t := tq.NewTask("/hello/world")
+                                t := &tqS.Task{Path: "/hello/world"}
 
                                 Convey("works", func() {
                                         t.Delay = 4 * time.Second
                                         t.Header = http.Header{}
                                         t.Header.Add("Cat", "tabby")
                                         t.Payload = []byte("watwatwat")
                                         t.RetryOptions = &tqS.RetryOptions{AgeLimit: 7 * time.Second}
                                         So(tq.Add(t, ""), ShouldBeNil)
 
                                         name := "Z_UjshxM9ecyMQfGbZmUGOEcgxWU0_5CGLl_-RntudwAw2DqQ5-58bzJiWQN4OKzeuUb9O4JrPkUw2rOvk2Ax46THojnQ6avBQgZdrKcJmrwQ6o4qKfJdiyUbGXvy691yRfzLeQhs6cBhWrgf3wH-VPMcA4SC-zlbJ2U8An7I0zJQA5nBFnMNoMgT-2peGoay3rCSbj4z9VFFm9kS_i6JCaQH518ujLDSNCYdjTq6B6lcWrZAh0U_q3a1S2nXEwrKiw_t9MTNQFgAQZWyGBbvZQPmeRYtu8SPaWzTfd25v_YWgBuVL2rRSPSMvlDwE04nNdtvVzE8vNNiA1zRimmdzKeqATQF9_ReUvj4D7U8dcS703DZWfKMBLgBffY9jqCassOOOw77V72Oq5EVauUw3Qw0L6bBsfM9FtahTKUdabzRZjXUoze3EK4KXPt3-wdidau-8JrVf2XFocjjZbwHoxcGvbtT3b4nGLDlgwdC00bwaFBZWff"
                                         So(tqt.GetScheduledTasks()["default"][name], ShouldResemble, &tqS.Task{
                                                 ETA:          now.Add(4 * time.Second),
                                                 Header:       http.Header{"Cat": []string{"tabby"}},
                                                 Method:       "POST",
                                                 Name:         name,
                                                 Path:         "/hello/world",
                                                 Payload:      []byte("watwatwat"),
                                                 RetryOptions: &tqS.RetryOptions{AgeLimit: 7 * time.Second},
                                         })
                                 })
 
                                 Convey("picks up namespace", func() {
                                         c, err := info.Get(c).Namespace("coolNamespace")
                                         So(err, ShouldBeNil)
                                         tq = tqS.Get(c)
 
-                                        t := tq.NewTask("")
+                                        t := &tqS.Task{Path: ""}

[iannucci, 2016/04/16 01:26:43]

Task{}

[dnj, 2016/04/16 01:50:26]

Done.

                                         So(tq.Add(t, ""), ShouldBeNil)
                                         So(t.Header, ShouldResemble, http.Header{
                                                 "X-Appengine-Current-Namespace": {"coolNamespace"},
                                         })
 
                                 })
 
                                 Convey("cannot add to bad queues", func() {
                                         So(tq.Add(nil, "waaat").Error(), ShouldContainSubstring, "UNKNOWN_QUEUE")
 
@@ skipping 71 matching lines @@
                                                 Convey(fmt.Sprintf("task %d: %s", i, expect[i].Path), func() {
                                                         So(expect[i].Method, ShouldEqual, "POST")
                                                         So(expect[i].ETA, ShouldHappenOnOrBefore, now)
                                                         So(len(expect[i].Name), ShouldEqual, 500)
                                                 })
                                         }
 
                                         Convey("stats work too", func() {
                                                 delay := -time.Second * 400
 
-                                                t := tq.NewTask("/somewhere")
+                                                t := &tqS.Task{Path: "/somewhere"}
                                                 t.Delay = delay
                                                 So(tq.Add(t, ""), ShouldBeNil)
 
                                                 stats, err := tq.Stats("")
                                                 So(err, ShouldBeNil)
                                                 So(stats[0].Tasks, ShouldEqual, 3)
                                                 So(stats[0].OldestETA, ShouldHappenOnOrBefore, clock.Now(c).Add(delay))
 
                                                 _, err = tq.Stats("noexist")
                                                 So(err.Error(), ShouldContainSubstring, "UNKNOWN_QUEUE")
@@ skipping 203 matching lines @@
                                         So(tqS.GetNoTxn(c).Delete(t, ""), ShouldBeNil)
                                         So(tqS.GetNoTxn(c).Purge(""), ShouldBeNil)
                                         _, err := tqS.GetNoTxn(c).Stats("")
                                         So(err, ShouldBeNil)
                                         return nil
                                 }, nil), ShouldBeNil)
                         })
 
                         Convey("adding a new task only happens if we don't errout", func() {
                                 So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
-                                        t3 := tq.NewTask("/sandwitch/victory")
+                                        t3 := &tqS.Task{Path: "/sandwitch/victory"}
                                         So(tqS.Get(c).Add(t3, ""), ShouldBeNil)
                                         return fmt.Errorf("nooooo")
                                 }, nil), ShouldErrLike, "nooooo")
 
                                 So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
                                 So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
                                 So(tqt.GetTransactionTasks()["default"], ShouldBeNil)
                         })
 
                         Convey("likewise, a panic doesn't schedule anything", func() {
                                 func() {
                                         defer func() { _ = recover() }()
                                         So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
                                                 tq := tqS.Get(c)
 
-                                                So(tq.Add(tq.NewTask("/sandwitch/victory"), ""), ShouldBeNil)
+                                                So(tq.Add(&tqS.Task{Path: "/sandwitch/victory"}, ""), ShouldBeNil)
 
                                                 panic(fmt.Errorf("nooooo"))
                                         }, nil), ShouldBeNil)
                                 }()
 
                                 So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
                                 So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
                                 So(tqt.GetTransactionTasks()["default"], ShouldBeNil)
                         })
 
                 })
         })
 }