请为我提供一个golang 类这个类需要提供插入交易记录、统计某个时间段内交易总金额功能 和 删除老的交易记录。并且可以忽略被重复插入的交易即忽略已存在相同交易订单的交易。请同时提供单元测试

以下是一个简单的golang类，实现了插入交易记录、统计某个时间段内交易总金额功能和删除老的交易记录，并且可以忽略被重复插入的交易。

package transaction

import (
    "sync"
    "time"
)

type Transaction struct {
    OrderId   string
    Amount    float64
    Timestamp time.Time
}

type TransactionManager struct {
    transactions map[string]Transaction
    lock         sync.Mutex
}

func NewTransactionManager() *TransactionManager {
    return &TransactionManager{
        transactions: make(map[string]Transaction),
    }
}

func (tm *TransactionManager) Insert(transaction Transaction) bool {
    tm.lock.Lock()
    defer tm.lock.Unlock()

    if _, ok := tm.transactions[transaction.OrderId]; ok {
        return false // already exists
    }

    tm.transactions[transaction.OrderId] = transaction
    return true
}

func (tm *TransactionManager) TotalAmount(startTime time.Time, endTime time.Time) float64 {
    tm.lock.Lock()
    defer tm.lock.Unlock()

    total := 0.0
    for _, transaction := range tm.transactions {
        if transaction.Timestamp.After(startTime) && transaction.Timestamp.Before(endTime) {
            total += transaction.Amount
        }
    }

    return total
}

func (tm *TransactionManager) DeleteOlderThan(duration time.Duration) {
    tm.lock.Lock()
    defer tm.lock.Unlock()

    now := time.Now()
    for orderId, transaction := range tm.transactions {
        if now.Sub(transaction.Timestamp) > duration {
            delete(tm.transactions, orderId)
        }
    }
}

以下是对上述类的单元测试：

package transaction

import (
    "testing"
    "time"
)

func TestTransactionManager_Insert(t *testing.T) {
    tm := NewTransactionManager()

    // insert a new transaction
    transaction := Transaction{
        OrderId:   "abc123",
        Amount:    10.0,
        Timestamp: time.Now(),
    }
    if !tm.Insert(transaction) {
        t.Errorf("expected to insert new transaction, but failed")
    }

    // insert a duplicate transaction
    if tm.Insert(transaction) {
        t.Errorf("expected to ignore duplicate transaction, but succeeded")
    }
}

func TestTransactionManager_TotalAmount(t *testing.T) {
    tm := NewTransactionManager()

    // insert some transactions
    tm.Insert(Transaction{
        OrderId:   "abc123",
        Amount:    10.0,
        Timestamp: time.Now(),
    })
    tm.Insert(Transaction{
        OrderId:   "def456",
        Amount:    20.0,
        Timestamp: time.Now().Add(-time.Hour),
    })

    // total amount from last hour
    total := tm.TotalAmount(time.Now().Add(-time.Hour), time.Now())
    if total != 20.0 {
        t.Errorf("expected total amount to be 20.0, but got %f", total)
    }
}

func TestTransactionManager_DeleteOlderThan(t *testing.T) {
    tm := NewTransactionManager()

    // insert some transactions
    tm.Insert(Transaction{
        OrderId:   "abc123",
        Amount:    10.0,
        Timestamp: time.Now().Add(-time.Hour),
    })
    tm.Insert(Transaction{
        OrderId:   "def456",
        Amount:    20.0,
        Timestamp: time.Now(),
    })

    // delete transactions older than 30 minutes
    tm.DeleteOlderThan(time.Minute * 30)

    // check number of transactions
    if len(tm.transactions) != 1 {
        t.Errorf("expected one transaction remaining, but got %d", len(tm.transactions))
    }

    // check remaining transaction
    for _, transaction := range tm.transactions {
        if transaction.OrderId != "def456" {
            t.Errorf("expected remaining transaction to have OrderId def456, but got %s", transaction.OrderId)
        }
    }
}