예제 #1
0
func TestPrefixedSchemaName(t *testing.T) {
	const prefix = "SomePrefix"

	origSchemaNameForType := SchemaNameForType
	defer func() { SchemaNameForType = origSchemaNameForType }()
	SchemaNameForType = func(t reflect.Type) string {
		return prefix + t.Name()
	}

	d := createDescriptor(t)
	for name := range d.Descriptor.Schemas {
		if !strings.HasPrefix(name, prefix) {
			t.Errorf("HasPrefix(%q, %q) = false", name, prefix)
		}
	}

	for mname, meth := range d.Descriptor.Methods {
		if meth.Request != nil {
			if !strings.HasPrefix(meth.Request.Ref, prefix) {
				t.Errorf("HasPrefix(%q, %q) = false; request of %q",
					meth.Request.Ref, prefix, mname)
			}
		}
		if meth.Response != nil {
			if !strings.HasPrefix(meth.Response.Ref, prefix) {
				t.Errorf("HasPrefix(%q, %q) = false; response of %q",
					meth.Response.Ref, prefix, mname)
			}
		}
	}
}
예제 #2
0
func TestGrammar(t *testing.T) {
	bnf0 := GenerateBnf0Grammar()
	g := GetIndexedGrammar(bnf0)
	idxIf, err := g.GetIndex(GrammarIndexTypeTerm)
	if err != nil {
		t.Error(err)
		return
	}
	termIndex := idxIf.(TermGrammarIndex)
	for _, ntn := range termIndex.GetNonterminalNames() {
		nt, _ := termIndex.GetNonterminal(ntn)
		fmt.Printf("%d: <%s>\n", nt.Id(), nt.Name())
	}
	for _, tn := range termIndex.GetTerminalNames() {
		t, _ := termIndex.GetTerminal(tn)
		fmt.Printf("%d: %s\n", t.Id(), t.Name())
	}
}
예제 #3
0
func TestTaskQueue(t *testing.T) {
	t.Parallel()

	Convey("TaskQueue", t, func() {
		now := time.Date(2000, time.January, 1, 1, 1, 1, 1, time.UTC)
		c, tc := testclock.UseTime(context.Background(), now)
		c = mathrand.Set(c, rand.New(rand.NewSource(clock.Now(c).UnixNano())))
		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")

				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("")
					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")

					Convey("but you can add Queues when testing", func() {
						tqt.CreateQueue("waaat")
						So(tq.Add(t, "waaat"), ShouldBeNil)

						Convey("you just can't add them twice", func() {
							So(func() { tqt.CreateQueue("waaat") }, ShouldPanic)
						})
					})
				})

				Convey("supplies a URL if it's missing", func() {
					t.Path = ""
					So(tq.Add(t, ""), ShouldBeNil)
					So(t.Path, ShouldEqual, "/_ah/queue/default")
				})

				Convey("cannot add twice", func() {
					t.Name = "bob"
					So(tq.Add(t, ""), ShouldBeNil)

					// can't add the same one twice!
					So(tq.Add(t, ""), ShouldEqual, tqS.ErrTaskAlreadyAdded)
				})

				Convey("cannot add deleted task", func() {
					t.Name = "bob"
					So(tq.Add(t, ""), ShouldBeNil)

					So(tq.Delete(t, ""), ShouldBeNil)

					// can't add a deleted task!
					So(tq.Add(t, ""), ShouldEqual, tqS.ErrTaskAlreadyAdded)
				})

				Convey("cannot set ETA+Delay", func() {
					t.ETA = clock.Now(c).Add(time.Hour)
					tc.Add(time.Second)
					t.Delay = time.Hour
					So(func() {
						So(tq.Add(t, ""), ShouldBeNil)
					}, ShouldPanic)
				})

				Convey("must use a reasonable method", func() {
					t.Method = "Crystal"
					So(tq.Add(t, "").Error(), ShouldContainSubstring, "bad method")
				})

				Convey("payload gets dumped for non POST/PUT methods", func() {
					t.Method = "HEAD"
					t.Payload = []byte("coool")
					So(tq.Add(t, ""), ShouldBeNil)
					So(t.Payload, ShouldBeNil)
				})

				Convey("invalid names are rejected", func() {
					t.Name = "happy times"
					So(tq.Add(t, "").Error(), ShouldContainSubstring, "INVALID_TASK_NAME")
				})

				Convey("AddMulti also works", func() {
					t2 := t.Duplicate()
					t2.Path = "/hi/city"

					expect := []*tqS.Task{t, t2}

					So(tq.AddMulti(expect, "default"), ShouldBeNil)
					So(len(expect), ShouldEqual, 2)
					So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 2)

					for i := range expect {
						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.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")
					})

					Convey("can purge all tasks", func() {
						So(tq.Add(&tqS.Task{Path: "/wut/nerbs"}, ""), ShouldBeNil)
						So(tq.Purge(""), ShouldBeNil)

						So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 0)
						So(len(tqt.GetTombstonedTasks()["default"]), ShouldEqual, 0)
						So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 0)

						Convey("purging a queue which DNE fails", func() {
							So(tq.Purge("noexist").Error(), ShouldContainSubstring, "UNKNOWN_QUEUE")
						})
					})

				})
			})

			Convey("Delete", func() {
				t := &tqS.Task{Path: "/hello/world"}
				So(tq.Add(t, ""), ShouldBeNil)

				Convey("works", func() {
					err := tq.Delete(t, "")
					So(err, ShouldBeNil)
					So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 0)
					So(len(tqt.GetTombstonedTasks()["default"]), ShouldEqual, 1)
					So(tqt.GetTombstonedTasks()["default"][t.Name], ShouldResemble, t)
				})

				Convey("cannot delete a task twice", func() {
					So(tq.Delete(t, ""), ShouldBeNil)

					So(tq.Delete(t, "").Error(), ShouldContainSubstring, "TOMBSTONED_TASK")

					Convey("but you can if you do a reset", func() {
						tqt.ResetTasks()

						So(tq.Add(t, ""), ShouldBeNil)
						So(tq.Delete(t, ""), ShouldBeNil)
					})
				})

				Convey("cannot delete from bogus queues", func() {
					err := tq.Delete(t, "wat")
					So(err.Error(), ShouldContainSubstring, "UNKNOWN_QUEUE")
				})

				Convey("cannot delete a missing task", func() {
					t.Name = "tarntioarenstyw"
					err := tq.Delete(t, "")
					So(err.Error(), ShouldContainSubstring, "UNKNOWN_TASK")
				})

				Convey("DeleteMulti also works", func() {
					t2 := t.Duplicate()
					t2.Name = ""
					t2.Path = "/hi/city"
					So(tq.Add(t2, ""), ShouldBeNil)

					Convey("usually works", func() {
						So(tq.DeleteMulti([]*tqS.Task{t, t2}, ""), ShouldBeNil)
						So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 0)
						So(len(tqt.GetTombstonedTasks()["default"]), ShouldEqual, 2)
					})
				})
			})
		})

		Convey("works with transactions", func() {
			t := &tqS.Task{Path: "/hello/world"}
			So(tq.Add(t, ""), ShouldBeNil)

			t2 := &tqS.Task{Path: "/hi/city"}
			So(tq.Add(t2, ""), ShouldBeNil)

			So(tq.Delete(t2, ""), ShouldBeNil)

			Convey("can view regular tasks", func() {
				So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
					tqt := tqS.GetRaw(c).Testable()

					So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
					So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
					So(tqt.GetTransactionTasks()["default"], ShouldBeNil)
					return nil
				}, nil), ShouldBeNil)
			})

			Convey("can add a new task", func() {
				t3 := &tqS.Task{Path: "/sandwitch/victory"}

				err := dsS.Get(c).RunInTransaction(func(c context.Context) error {
					tq := tqS.Get(c)
					tqt := tq.Testable()

					So(tq.Add(t3, ""), ShouldBeNil)
					So(t3.Name, ShouldEqual, "")

					So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
					So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
					So(tqt.GetTransactionTasks()["default"][0], ShouldResemble, t3)
					return nil
				}, nil)
				So(err, ShouldBeNil)

				for _, tsk := range tqt.GetScheduledTasks()["default"] {
					if tsk.Name == t.Name {
						So(tsk, ShouldResemble, t)
					} else {
						tsk.Name = ""
						So(tsk, ShouldResemble, t3)
					}
				}

				So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
				So(tqt.GetTransactionTasks()["default"], ShouldBeNil)
			})

			Convey("can add a new task (but reset the state in a test)", func() {
				t3 := &tqS.Task{Path: "/sandwitch/victory"}

				ttq := tqS.Interface(nil)

				So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
					ttq = tqS.Get(c)
					tqt := ttq.Testable()

					So(ttq.Add(t3, ""), ShouldBeNil)

					So(tqt.GetScheduledTasks()["default"][t.Name], ShouldResemble, t)
					So(tqt.GetTombstonedTasks()["default"][t2.Name], ShouldResemble, t2)
					So(tqt.GetTransactionTasks()["default"][0], ShouldResemble, t3)

					tqt.ResetTasks()

					So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 0)
					So(len(tqt.GetTombstonedTasks()["default"]), ShouldEqual, 0)
					So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 0)

					return nil
				}, nil), ShouldBeNil)

				So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 0)
				So(len(tqt.GetTombstonedTasks()["default"]), ShouldEqual, 0)
				So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 0)

				Convey("and reusing a closed context is bad times", func() {
					So(ttq.Add(nil, "").Error(), ShouldContainSubstring, "expired")
				})
			})

			Convey("you can AddMulti as well", func() {
				So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
					tq := tqS.Get(c)
					tqt := tq.Testable()

					t.Name = ""
					tasks := []*tqS.Task{t.Duplicate(), t.Duplicate(), t.Duplicate()}
					So(tq.AddMulti(tasks, ""), ShouldBeNil)
					So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 1)
					So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 3)
					return nil
				}, nil), ShouldBeNil)
				So(len(tqt.GetScheduledTasks()["default"]), ShouldEqual, 4)
				So(len(tqt.GetTransactionTasks()["default"]), ShouldEqual, 0)
			})

			Convey("unless you add too many things", func() {
				So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
					for i := 0; i < 5; i++ {
						So(tqS.Get(c).Add(t.Duplicate(), ""), ShouldBeNil)
					}
					So(tqS.Get(c).Add(t, "").Error(), ShouldContainSubstring, "BAD_REQUEST")
					return nil
				}, nil), ShouldBeNil)
			})

			Convey("unless you Add to a bad queue", func() {
				So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
					So(tqS.Get(c).Add(t, "meat").Error(), ShouldContainSubstring, "UNKNOWN_QUEUE")

					Convey("unless you add it!", func() {
						tqS.GetRaw(c).Testable().CreateQueue("meat")
						So(tqS.Get(c).Add(t, "meat"), ShouldBeNil)
					})

					return nil
				}, nil), ShouldBeNil)
			})

			Convey("No other features are available, however", func() {
				So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
					So(tqS.Get(c).Delete(t, "").Error(), ShouldContainSubstring, "cannot DeleteMulti from a transaction")
					So(tqS.Get(c).Purge("").Error(), ShouldContainSubstring, "cannot Purge from a transaction")
					_, err := tqS.Get(c).Stats("")
					So(err.Error(), ShouldContainSubstring, "cannot Stats from a transaction")
					return nil
				}, nil), ShouldBeNil)
			})

			Convey("can get the non-transactional taskqueue context though", func() {
				So(dsS.Get(c).RunInTransaction(func(c context.Context) error {
					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")
					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)

						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)
			})

		})
	})
}
예제 #4
0
func TestFindTypeCycles(t *testing.T) {
	tests := []struct {
		desc string
		typ  TypeSpec
		msgs []string
	}{
		{
			desc: "self-referential typedef",
			typ: withTypedef(func(t *TypedefSpec) {
				t.Name = "foo"
				t.Target = t
			}),
			msgs: []string{
				"found a type reference cycle",
				"   foo",
				"-> foo",
			},
		},
		{
			desc: "mutually recursive references",
			typ: withTypedef(func(x *TypedefSpec) {
				x.Name = "foo"
				x.Target = &TypedefSpec{
					Name:   "bar",
					File:   "test.thrift",
					Target: x,
				}
			}),
			msgs: []string{
				"found a type reference cycle",
				"   foo",
				"-> bar",
				"-> foo",
			},
		},
		{
			desc: "recurse from map",
			typ: withTypedef(func(t *TypedefSpec) {
				t.Name = "foo"
				t.Target = &MapSpec{
					KeySpec:   &StringSpec{},
					ValueSpec: t,
				}
			}),
			msgs: []string{
				"found a type reference cycle",
				"   foo",
				"-> map<string, foo>",
				"-> foo",
			},
		},
		{
			desc: "recurse from list",
			typ: withTypedef(func(t *TypedefSpec) {
				t.Name = "foo"
				t.Target = &ListSpec{ValueSpec: t}
			}),
			msgs: []string{
				"found a type reference cycle",
				"   foo",
				"-> list<foo>",
				"-> foo",
			},
		},
		{
			desc: "recurse from set",
			typ: withTypedef(func(t *TypedefSpec) {
				t.Name = "foo"
				t.Target = &SetSpec{ValueSpec: t}
			}),
			msgs: []string{
				"found a type reference cycle",
				"   foo",
				"-> set<foo>",
				"-> foo",
			},
		},
		{
			desc: "recurse from struct",
			typ: withTypedef(func(t *TypedefSpec) {
				t.Name = "foo"
				t.Target = &StructSpec{
					Name: "bar",
					File: "test.thrift",
					Type: ast.StructType,
					Fields: FieldGroup{
						{
							ID:       1,
							Name:     "foo",
							Type:     t,
							Required: true,
						},
					},
				}
			}),
		},
	}

	for _, tt := range tests {
		typ := mustLink(t, tt.typ, defaultScope)

		err := findTypeCycles(typ)
		if len(tt.msgs) > 0 {
			if assert.Error(t, err, tt.desc) {
				for _, msg := range tt.msgs {
					assert.Contains(t, err.Error(), msg)
				}
			}
		} else {
			assert.NoError(t, err, tt.desc)
		}
	}
}
예제 #5
0
func TestApiClient(t *testing.T) {
	done := make(chan struct{})
	defer func() {
		close(done)
		time.Sleep(time.Second)
	}()
	url := startApi(done)
	agentCount := 1
	metricsCount := 2
	taskCount := 0
	Convey("Client should exist", t, func() {
		c, cerr := New(url, adminKey, false)
		So(cerr, ShouldBeNil)
		Convey("When calling the api heartbeat method", func() {
			ok, hErr := c.Heartbeat()
			So(hErr, ShouldBeNil)
			So(ok, ShouldBeTrue)
		})

		Convey("when adding a new Agent", func() {
			agentCount++
			pre := time.Now()
			a := model.AgentDTO{
				Name:    fmt.Sprintf("demo%d", agentCount),
				Enabled: true,
				Public:  false,
				Tags:    []string{"demo", "private"},
			}

			aErr := c.AddAgent(&a)

			So(aErr, ShouldBeNil)
			So(a.Id, ShouldNotBeEmpty)
			So(a.Name, ShouldEqual, fmt.Sprintf("demo%d", agentCount))
			So(a.Enabled, ShouldEqual, true)
			So(a.Public, ShouldEqual, false)
			So(a.Created, ShouldHappenBefore, time.Now())
			So(a.Created, ShouldHappenAfter, pre)
			So(a.Created.Unix(), ShouldEqual, a.Updated.Unix())

			Convey("when getting an agent by id", func() {
				agent, err := c.GetAgentById(a.Id)
				So(err, ShouldBeNil)
				So(agent, ShouldNotBeNil)
				So(agent, ShouldHaveSameTypeAs, &model.AgentDTO{})
				So(agent.Id, ShouldEqual, a.Id)
				So(agent.Created.Unix(), ShouldEqual, a.Created.Unix())
				Convey("when updating an Agent", func() {
					a := new(model.AgentDTO)
					*a = *agent
					a.Name = "test1"
					pre := time.Now()
					err := c.UpdateAgent(a)
					So(err, ShouldBeNil)
					So(a.Id, ShouldNotBeEmpty)
					So(a.Name, ShouldEqual, "test1")
					So(a.Enabled, ShouldEqual, true)
					So(a.Public, ShouldEqual, false)
					So(a.Created, ShouldHappenBefore, pre)
					So(a.Updated, ShouldHappenAfter, pre)
				})
				Convey("When deleting an agent", func() {
					err := c.DeleteAgent(&a)
					So(err, ShouldBeNil)
					agentCount--

					Convey("When searching for agent by name", func() {
						query := model.GetAgentsQuery{Name: a.Name}
						agents, err := c.GetAgents(&query)
						So(err, ShouldBeNil)
						So(len(agents), ShouldEqual, 0)
					})
				})
			})
			Convey("When getting the list of Agents", func() {
				query := model.GetAgentsQuery{}
				agents, err := c.GetAgents(&query)

				So(err, ShouldBeNil)
				So(len(agents), ShouldEqual, agentCount)
			})
		})

		Convey("When getting list of public agenst", func() {

			query := model.GetAgentsQuery{Public: "true"}
			agents, err := c.GetAgents(&query)

			So(err, ShouldBeNil)
			So(len(agents), ShouldEqual, 1)
			So(agents[0].Id, ShouldEqual, 1)

			Convey("When updating tags of public agent", func() {
				a := new(model.AgentDTO)
				*a = *agents[0]
				a.Tags = []string{"foo", "demo"}
				err := c.UpdateAgent(a)
				So(err, ShouldBeNil)
				So(a.Id, ShouldNotBeEmpty)
				So(a.Name, ShouldEqual, "publicTest")
				So(a.Enabled, ShouldEqual, true)
				So(a.Public, ShouldEqual, true)
				So(len(a.Tags), ShouldEqual, 2)
			})
		})

		// Metric Tests
		Convey("When getting metrics list", func() {
			query := &model.GetMetricsQuery{}
			metrics, err := c.GetMetrics(query)
			So(err, ShouldBeNil)
			So(metrics, ShouldNotBeNil)
			So(metrics, ShouldHaveSameTypeAs, []*model.Metric{})
			So(len(metrics), ShouldEqual, metricsCount)
			agent, err := c.GetAgentById(2)
			if err != nil {
				panic(err)
			}
			addTestMetrics(agent)
			metricsCount = 3
			Convey("When getting metrics for Agent", func() {
				metrics, err := c.GetAgentMetrics(agent.Id)
				So(err, ShouldBeNil)
				So(metrics, ShouldNotBeNil)
				So(metrics, ShouldHaveSameTypeAs, []*model.Metric{})
				So(len(metrics), ShouldEqual, 2)
			})
			Convey("When getting agent with Metric", func() {
				q := &model.GetAgentsQuery{
					Metric: "/testing/demo/demo1",
				}
				agentsWithMetric, err := c.GetAgents(q)
				So(err, ShouldBeNil)
				So(agentsWithMetric, ShouldNotBeNil)
				So(agentsWithMetric, ShouldHaveSameTypeAs, []*model.AgentDTO{})
				So(len(agentsWithMetric), ShouldEqual, 1)
				So(agentsWithMetric[0].Id, ShouldEqual, agent.Id)
			})
			Convey("When getting agent with Metric wildcard", func() {
				q := &model.GetAgentsQuery{
					Metric: "/testing/public/*",
				}
				agentsWithMetric, err := c.GetAgents(q)
				So(err, ShouldBeNil)
				So(agentsWithMetric, ShouldNotBeNil)
				So(agentsWithMetric, ShouldHaveSameTypeAs, []*model.AgentDTO{})
				So(len(agentsWithMetric), ShouldEqual, 1)
				So(agentsWithMetric[0].Id, ShouldEqual, 1)
			})
			Convey("When getting agent with Metric wildcard that doesnt match", func() {
				q := &model.GetAgentsQuery{
					Metric: "/not-found/demo/*",
				}
				agentsWithMetric, err := c.GetAgents(q)
				So(err, ShouldBeNil)
				So(agentsWithMetric, ShouldNotBeNil)
				So(agentsWithMetric, ShouldHaveSameTypeAs, []*model.AgentDTO{})
				So(len(agentsWithMetric), ShouldEqual, 0)
			})
		})

		Convey("When getting list of tasks", func() {
			query := model.GetTasksQuery{}
			tasks, err := c.GetTasks(&query)
			So(err, ShouldBeNil)
			So(tasks, ShouldNotBeNil)
			So(len(tasks), ShouldEqual, taskCount)
			So(tasks, ShouldHaveSameTypeAs, []*model.TaskDTO{})
			Convey("When Adding new Task", func() {
				pre := time.Now()
				taskCount++
				t := &model.TaskDTO{
					Name:     fmt.Sprintf("test Task%d", taskCount),
					Interval: 60,
					Config: map[string]map[string]interface{}{"/": {
						"user":   "******",
						"passwd": "test",
					}},
					Metrics: map[string]int64{"/testing/demo/demo1": 0},
					Route: &model.TaskRoute{
						Type: "any",
					},
					Enabled: true,
				}
				err := c.AddTask(t)
				So(err, ShouldBeNil)
				So(t.Id, ShouldNotBeEmpty)
				So(t.Name, ShouldEqual, fmt.Sprintf("test Task%d", taskCount))
				So(t.Created, ShouldHappenBefore, time.Now())
				So(t.Created, ShouldHappenAfter, pre)
				So(t.Created.Unix(), ShouldEqual, t.Updated.Unix())
				Convey("When adding first task", func() {
					So(len(tasks), ShouldEqual, 0)
				})
				Convey("When adding second task", func() {
					So(len(tasks), ShouldEqual, 1)
				})

			})
			Convey("when updating task", func() {
				pre := time.Now()
				t := new(model.TaskDTO)
				*t = *tasks[0]
				t.Name = "demo"
				err := c.UpdateTask(t)
				So(err, ShouldBeNil)
				So(t.Id, ShouldEqual, tasks[0].Id)
				So(t.Name, ShouldEqual, "demo")
				So(t.Created, ShouldHappenBefore, pre)
				So(t.Updated, ShouldHappenAfter, pre)
				So(t.Updated, ShouldHappenAfter, t.Created)
			})
			Convey("When Adding new Task with route by tag", func() {
				t := &model.TaskDTO{
					Name:     "task route by tags",
					Interval: 60,
					Config: map[string]map[string]interface{}{"/": {
						"user":   "******",
						"passwd": "test",
					}},
					Metrics: map[string]int64{"/testing/demo2/demo": 0},
					Route: &model.TaskRoute{
						Type:   model.RouteByTags,
						Config: map[string]interface{}{"tags": []string{"demo"}},
					},
					Enabled: true,
				}
				taskCount++
				err = c.AddTask(t)
				So(err, ShouldBeNil)

				Convey("When getting agentTasks", func() {
					tasks, err := sqlstore.GetAgentTasks(&model.AgentDTO{Id: 1, OrgId: 1000})
					So(err, ShouldBeNil)
					So(len(tasks), ShouldEqual, 1)
					So(tasks[0].Name, ShouldEqual, "task route by tags")
					tasks, err = sqlstore.GetAgentTasks(&model.AgentDTO{Id: 2, OrgId: 1})
					So(err, ShouldBeNil)
					So(len(tasks), ShouldEqual, 3)
				})
			})
			Convey("When Adding new Task with route by tag matching only private probes", func() {
				t := &model.TaskDTO{
					Name:     "task route by tags2",
					Interval: 60,
					Config: map[string]map[string]interface{}{"/": {
						"user":   "******",
						"passwd": "test",
					}},
					Metrics: map[string]int64{"/testing/demo2/demo": 0},
					Route: &model.TaskRoute{
						Type:   model.RouteByTags,
						Config: map[string]interface{}{"tags": []string{"private"}},
					},
					Enabled: true,
				}
				taskCount++
				err = c.AddTask(t)
				So(err, ShouldBeNil)

				Convey("When getting agentTasks", func() {
					tasks, err := sqlstore.GetAgentTasks(&model.AgentDTO{Id: 1, OrgId: 1000})
					So(err, ShouldBeNil)
					So(len(tasks), ShouldEqual, 1)
					So(tasks[0].Name, ShouldEqual, "task route by tags")
					tasks, err = sqlstore.GetAgentTasks(&model.AgentDTO{Id: 2, OrgId: 1})
					So(err, ShouldBeNil)
					So(len(tasks), ShouldEqual, 4)
				})
			})
			Convey("When Adding new Task with no valid agents", func() {
				err := sqlstore.DeleteAgentSessionsByServer("localhost")
				So(err, ShouldBeNil)

				t := &model.TaskDTO{
					Name:     "task should fail",
					Interval: 60,
					Config: map[string]map[string]interface{}{"/": {
						"user":   "******",
						"passwd": "test",
					}},
					Metrics: map[string]int64{"/testing/demo/demo1": 0},
					Route: &model.TaskRoute{
						Type: "any",
					},
					Enabled: true,
				}
				err = c.AddTask(t)
				So(err, ShouldNotBeNil)
				So(err.Error(), ShouldEqual, "400: No agent found that can provide all requested metrics.")
			})
		})
	})
}