func setup(t *testing.T) (*amqpConnector, *MockamqpChannel, func()) {
	mockCtrl := gomock.NewController(t)

	mockChannel := NewMockamqpChannel(mockCtrl)
	ac := amqpConnector{
		chMaker: mockChannelMaker{
			channel: mockChannel,
		},
		queueName:        "fooqueue",
		retryTimeoutBase: time.Second,
	}
	return &ac, mockChannel, func() { mockCtrl.Finish() }
}
Exemple #2
0
func TestScopedStatsStatsd(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()
	statter := NewMockStatter(ctrl)
	stats := NewStatsdScope(statter, "fake")
	statter.EXPECT().Inc("fake.counter", int64(2), float32(1.0)).Return(nil)
	stats.Inc("counter", 2)

	statter.EXPECT().Dec("fake.counter", int64(2), float32(1.0)).Return(nil)
	stats.Dec("counter", 2)

	statter.EXPECT().Gauge("fake.gauge", int64(2), float32(1.0)).Return(nil)
	stats.Gauge("gauge", 2)
	statter.EXPECT().GaugeDelta("fake.delta", int64(2), float32(1.0)).Return(nil)
	stats.GaugeDelta("delta", 2)
	statter.EXPECT().Timing("fake.latency", int64(2), float32(1.0)).Return(nil)
	stats.Timing("latency", 2)
	statter.EXPECT().TimingDuration("fake.latency", 2*time.Second, float32(1.0)).Return(nil)
	stats.TimingDuration("latency", 2*time.Second)
	statter.EXPECT().Set("fake.something", "value", float32(1.0)).Return(nil)
	stats.Set("something", "value")
	statter.EXPECT().SetInt("fake.someint", int64(10), float32(1.0)).Return(nil)
	stats.SetInt("someint", 10)
	statter.EXPECT().Raw("fake.raw", "raw value", float32(1.0)).Return(nil)
	stats.Raw("raw", "raw value")

	s := stats.NewScope("foobar")
	statter.EXPECT().Inc("fake.foobar.counter", int64(3), float32(1.0)).Return(nil)
	s.Inc("counter", 3)
	ss := stats.NewScope("another", "level")
	statter.EXPECT().Inc("fake.foobar.counter", int64(4), float32(1.0)).Return(nil)
	s.Inc("counter", 4)

	if stats.Scope() != "fake" {
		t.Errorf(`expected "fake", got %#v`, stats.Scope())
	}
	if s.Scope() != "fake.foobar" {
		t.Errorf(`expected "fake.foobar", got %#v`, s.Scope())
	}
	if ss.Scope() != "fake.another.level" {
		t.Errorf(`expected "fake.foobar", got %#v`, s.Scope())
	}

	twoScope := NewStatsdScope(statter, "fake", "bang")
	statter.EXPECT().Inc("fake.bang.counter", int64(7), float32(1.0)).Return(nil)
	twoScope.Inc("counter", 7)

}
Exemple #3
0
func TestIsSafeDomain(t *testing.T) {
	// TODO(jmhodges): use more of the GSB lib by teaching it how to not make
	// http requests
	// This test is mocked out at the wrong level (SafeBrowsing) because the gsb lib
	// we rely on is a little funny and overcomplicated, but still hasn't
	// learned out how not make HTTP requests in tests.

	stats, _ := statsd.NewNoopClient()
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	sbc := NewMockSafeBrowsing(ctrl)
	sbc.EXPECT().IsListed("good.com").Return("", nil)
	sbc.EXPECT().IsListed("bad.com").Return("bad", nil)
	sbc.EXPECT().IsListed("errorful.com").Return("", errors.New("welp"))
	sbc.EXPECT().IsListed("outofdate.com").Return("", safebrowsing.ErrOutOfDateHashes)
	va := NewValidationAuthorityImpl(&PortConfig{}, sbc, stats, clock.NewFake())

	resp, err := va.IsSafeDomain(&core.IsSafeDomainRequest{Domain: "good.com"})
	if err != nil {
		t.Errorf("good.com: want no error, got '%s'", err)
	}
	if !resp.IsSafe {
		t.Errorf("good.com: want true, got %t", resp.IsSafe)
	}
	resp, err = va.IsSafeDomain(&core.IsSafeDomainRequest{Domain: "bad.com"})
	if err != nil {
		t.Errorf("bad.com: want no error, got '%s'", err)
	}
	if resp.IsSafe {
		t.Errorf("bad.com: want false, got %t", resp.IsSafe)
	}
	_, err = va.IsSafeDomain(&core.IsSafeDomainRequest{Domain: "errorful.com"})
	if err == nil {
		t.Errorf("errorful.com: want error, got none")
	}
	resp, err = va.IsSafeDomain(&core.IsSafeDomainRequest{Domain: "outofdate.com"})
	if err != nil {
		t.Errorf("outofdate.com: want no error, got '%s'", err)
	}
	if !resp.IsSafe {
		t.Errorf("outofdate.com: IsSafeDomain should fail open on out of date hashes")
	}
}