}

var (
	// TestDir
	queueDir = filepath.Join(os.TempDir(), "minio_test")
	// Sample test item.
	testItem = TestItem{Name: "test-item", Property: "property"}
	// Ext for test item
	testItemExt = ".test"
)

// Initialize the queue store.
func setUpQueueStore(directory string, limit uint64) (Store[TestItem], error) {
	queueStore := NewQueueStore[TestItem](queueDir, limit, testItemExt)

			ClientCert:  clientCert,
			ClientKey:   clientKey,
			Proxy:       getCfgVal(EnvLoggerWebhookProxy, k, kv.Get(Proxy)),
			BatchSize:   batchSize,
			QueueSize:   queueSize,
			QueueDir:    getCfgVal(EnvLoggerWebhookQueueDir, k, kv.Get(QueueDir)),
			MaxRetry:    maxRetry,
			RetryIntvl:  retryInterval,
			Name:        loggerTargetNamePrefix + k,
		}
	}
	return cfg, nil
}

		User      string `json:"username"`
		Password  string `json:"password"`
		Mechanism string `json:"mechanism"`
	} `json:"sasl"`
	// Queue store
	QueueSize int    `json:"queueSize"`
	QueueDir  string `json:"queueDir"`

	// Custom logger
	LogOnce func(ctx context.Context, err error, id string, errKind ...any) `json:"-"`
}

// Target - Kafka target.
type Target struct {
	status int32

	totalMessages  int64

	var queueStore store.Store[event.Event]
	if args.QueueDir != "" {
		queueDir := filepath.Join(args.QueueDir, storePrefix+"-elasticsearch-"+id)
		queueStore = store.NewQueueStore[event.Event](queueDir, args.QueueLimit, event.StoreExtension)
		if err := queueStore.Open(); err != nil {

	ClientCert  string            `json:"clientCert"`
	ClientKey   string            `json:"clientKey"`
	BatchSize   int               `json:"batchSize"`
	QueueSize   int               `json:"queueSize"`
	QueueDir    string            `json:"queueDir"`
	MaxRetry    int               `json:"maxRetry"`
	RetryIntvl  time.Duration     `json:"retryInterval"`
	Proxy       string            `json:"string"`
	Transport   http.RoundTripper `json:"-"`

	"time"
)

func TestBatchCommit(t *testing.T) {
	defer func() {
		if err := tearDownQueueStore(); err != nil {
			t.Fatalf("Failed to tear down store; %v", err)
		}
	}()
	store, err := setUpQueueStore(queueDir, 100)
	if err != nil {
		t.Fatalf("Failed to create a queue store; %v", err)
	}

	var limit uint32 = 100

	batch := NewBatch[TestItem](BatchConfig[TestItem]{
		Limit:         limit,
		Store:         store,

		if err != nil {
			return nil, err
		}
		kafkaArgs := target.KafkaArgs{
			Enable:             enabled,
			Brokers:            brokers,
			Topic:              env.Get(topicEnv, kv.Get(target.KafkaTopic)),
			QueueDir:           env.Get(queueDirEnv, kv.Get(target.KafkaQueueDir)),
			QueueLimit:         queueLimit,
			Version:            env.Get(versionEnv, kv.Get(target.KafkaVersion)),
			BatchSize:          uint32(batchSize),

					Description: MetricDescription{
						Namespace: minioNamespace,
						Subsystem: notifySubsystem,
						Name:      "target_queue_length",
						Help:      "Number of events currently staged in the queue_dir configured for the target",
						Type:      gaugeMetric,
					},
					VariableLabels: map[string]string{"target_id": id.ID, "target_name": id.Name},
					Value:          float64(st.CurrentQueue),
				})
			}