Beispiel #1
0
func TestWithStacks(t *testing.T) {
	origin := fmt.Errorf("myerror")
	wrapped, isErrWithStacks := WithStacks(origin).(*ErrorWithStacks)
	assert.True(t, "isErrWithStacks", isErrWithStacks)
	assert.Equal(t, "wrapped.Err", wrapped.Err, origin)

	wrapped2, isErrWithStacks := WithStacks(wrapped).(*ErrorWithStacks)
	assert.True(t, "isErrWithStacks", isErrWithStacks)
	assert.Equal(t, "wrapped2", wrapped2, wrapped)
}
Beispiel #2
0
func TestWithStacksAndMessage(t *testing.T) {
	origin := fmt.Errorf("origin")
	wrapped, isErrWithStacks := WithStacksAndMessage(origin, "%s:%d", "a", 123).(*ErrorWithStacks)
	assert.True(t, "isErrWithStacks", isErrWithStacks)
	assert.Equal(t, "wrapped.Err", wrapped.Err, origin)
	assert.ValueShould(t, "wrapped.Stacks[0]", wrapped.Stacks[0], strings.HasSuffix(wrapped.Stacks[0], ": a:123"), "does not contain message correctly")

	wrapped2, isErrWithStacks := WithStacksAndMessage(wrapped, "%s:%d", "b", 456).(*ErrorWithStacks)
	assert.True(t, "isErrWithStacks", isErrWithStacks)
	assert.Equal(t, "wrapped.Err", wrapped2.Err, origin)
	assert.ValueShould(t, "wrapped2.Stacks[0]", wrapped2.Stacks[0], strings.HasSuffix(wrapped2.Stacks[0], ": a:123: b:456"), "does not contain message correctly")
}
Beispiel #3
0
func TestLikeGoSubFolder(t *testing.T) {
	pos_cases := []string{
		"go", "v8", "v-8",
	}
	for _, c := range pos_cases {
		assert.True(t, fmt.Sprintf("LikeGoSubFolder %v", c), LikeGoSubFolder(c))
	}
	neg_cases := []string{
		"js", "1234", "1234-5678", "1234_5678",
	}
	for _, c := range neg_cases {
		assert.False(t, fmt.Sprintf("LikeGoSubFolder %v", c), LikeGoSubFolder(c))
	}
}
Beispiel #4
0
func TestBoltFileCache(t *testing.T) {
	fn := filepath.Join(os.TempDir(), "TestBoltFileCache.bolt")
	assert.NoErrorOrDie(t, os.RemoveAll(fn))

	db, err := bh.Open(fn, 0755, nil)
	assert.NoErrorOrDie(t, err)

	counter := make(map[string]int)
	c := BoltFileCache{
		DB: db,
		IncCounter: func(name string) {
			counter[name] = counter[name] + 1
		},
	}
	const (
		sign1      = "abc"
		sign2      = "def"
		sign3      = "ghi"
		gofile     = "file.go"
		rootfolder = "root"
		sub        = "sub"
		subfolder  = "root/sub"
	)
	fi := &sppb.GoFileInfo{}

	//////////////////////////////////////////////////////////////
	// New file found.
	//////////////////////////////////////////////////////////////
	// Get before set, should return false
	assert.False(t, "c.Get", c.Get(sign1, fi))
	assert.Equal(t, "counter", counter, map[string]int{
		"crawler.filecache.missed": 1,
	})
	// Set the info.
	c.Set(sign1, &sppb.GoFileInfo{Status: sppb.GoFileInfo_ShouldIgnore})
	assert.Equal(t, "counter", counter, map[string]int{
		"crawler.filecache.missed":     1,
		"crawler.filecache.sign_saved": 1,
	})
	// Now, should fetch the cache
	assert.True(t, "c.Get", c.Get(sign1, fi))
	assert.Equal(t, "fi", fi, &sppb.GoFileInfo{Status: sppb.GoFileInfo_ShouldIgnore})
	assert.Equal(t, "counter", counter, map[string]int{
		"crawler.filecache.missed":     1,
		"crawler.filecache.sign_saved": 1,
		"crawler.filecache.hit":        1,
	})
}
Beispiel #5
0
func TestRefCountBox_OpenFuncFailed(t *testing.T) {
	fn := path.Join(os.TempDir(), "TestRefCountBox.bolt")
	assert.NoError(t, os.RemoveAll(fn))

	openFuncCalled := false
	failedErr := errors.New("failed")

	b := RefCountBox{
		DataPath: func() string { return fn },
		OpenFunc: func(path string) (DB, error) {
			openFuncCalled = true
			return DB{}, failedErr
		},
	}
	db, err := b.Alloc()
	assert.Equal(t, "err", errorsp.Cause(err), failedErr)
	assert.ValueShould(t, "db.DB", db.DB, db.DB == nil, "is not nil")
	assert.ValueShould(t, "b.db.DB", b.db.DB, b.db.DB == nil, "is not nil")
	assert.Equal(t, "b.count", b.count, 0)
	assert.True(t, "openFuncCalled", openFuncCalled)
}
Beispiel #6
0
func TestRefCountBox_OpenFunc(t *testing.T) {
	fn := path.Join(os.TempDir(), "TestRefCountBox.bolt")
	assert.NoError(t, os.RemoveAll(fn))

	openFuncCalled := false

	b := RefCountBox{
		DataPath: func() string { return fn },
		OpenFunc: func(path string) (DB, error) {
			openFuncCalled = true
			return Open(path, 0644, nil)
		},
	}
	db, err := b.Alloc()
	assert.NoError(t, err)
	assert.ValueShould(t, "db.DB", db.DB, db.DB != nil, "is nil")
	assert.Equal(t, "b.count", b.count, 1)
	assert.ValueShould(t, "b.db.DB", b.db.DB, b.db.DB != nil, "is nil")
	assert.True(t, "openFuncCalled", openFuncCalled)

	b.Free()
	assert.Equal(t, "b.count", b.count, 0)
	assert.ValueShould(t, "b.db.DB", b.db.DB, b.db.DB == nil, "is not nil")
}
func TestGobReadWrite(t *testing.T) {
	db := open(t, "TestGobReadWrite")
	defer db.Close()

	k := [][]byte{[]byte("a"), []byte("b")}

	// Testing Tx.PutGob and Tx.GobValue
	assert.NoErrorOrDie(t, db.Update(func(tx Tx) error {
		return tx.PutGob(k, &Da{S: "hello"})
	}))
	found1 := false
	assert.NoError(t, db.View(func(tx Tx) error {
		return tx.GobValue(k, func(v interface{}) error {
			found1 = true
			da, ok := v.(Da)
			assert.True(t, "ok", ok)
			assert.Equal(t, "da", da, Da{S: "hello"})
			return nil
		})
	}))
	assert.True(t, "found1", found1)
	found2 := false
	assert.NoError(t, db.View(func(tx Tx) error {
		return tx.ForEachGob(k[:len(k)-1], func(_ Bucket, k bytesp.Slice, v interface{}) error {
			found2 = true
			da, ok := v.(Da)
			assert.True(t, "ok", ok)
			assert.Equal(t, "da", da, Da{S: "hello"})
			return nil
		})
	}))
	assert.True(t, "found2", found2)

	// Testing Bucket.PutGob, Bucket.GobValue, Bucket.ForEachGob
	bk := [][]byte{[]byte("bbb")}
	assert.NoErrorOrDie(t, db.Update(func(tx Tx) error {
		b, err := tx.CreateBucketIfNotExists(bk)
		assert.NoErrorOrDie(t, err)
		return b.PutGob(k, &Da{S: "world"})
	}))
	found3 := false
	assert.NoError(t, db.View(func(tx Tx) error {
		return tx.Bucket(bk, func(b Bucket) error {
			return b.GobValue(k, func(v interface{}) error {
				found3 = true
				da, ok := v.(Da)
				assert.True(t, "ok", ok)
				assert.Equal(t, "da", da, Da{S: "world"})
				return nil
			})
		})
	}))
	assert.True(t, "found3", found3)
	found4 := false
	assert.NoError(t, db.View(func(tx Tx) error {
		return tx.Bucket(bk, func(b Bucket) error {
			return b.ForEachGob(k[:len(k)-1], func(k bytesp.Slice, v interface{}) error {
				found4 = true
				da, ok := v.(Da)
				assert.True(t, "ok", ok)
				assert.Equal(t, "da", da, Da{S: "world"})
				return nil
			})
		})
	}))
	assert.True(t, "found4", found4)
}