pm-file-converter/components/miniocollector/miniocollector_test.go

   1 package miniocollector
   2
   3 import (
   4         "bytes"
   5         "context"
   6         "io"
   7         "log"
   8         "os"
   9         "testing"
  10
  11         "github.com/minio/minio-go/v7"
  12         "github.com/minio/minio-go/v7/pkg/credentials"
  13         "github.com/stretchr/testify/assert"
  14 )
  15
  16 func TestMake_minio_bucket(t *testing.T) {
  17
  18         endpoint := "play.min.io:9000"
  19         accessKey := "Q3AM3UQ867SPQQA43P2F"
  20         secretKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"
  21
  22         minioClient, err := minio.New(endpoint, &minio.Options{
  23                 Creds:  credentials.NewStaticV4(accessKey, secretKey, ""),
  24                 Secure: true,
  25         })
  26         if err != nil {
  27                 log.Fatalf("Error creating Minio client: %v", err)
  28         }
  29
  30         if _, err := minioClient.ListBuckets(context.Background()); err != nil {
  31                 log.Fatalf("Error connecting to Minio server: %v", err)
  32         }
  33
  34         // Create a test bucket.
  35         bucketName := "my-test-bucket"
  36         err = create_minio_bucket(minioClient, bucketName)
  37         if err != nil {
  38                 log.Fatalf("Error creating bucket: %v", err)
  39         } else {
  40                 assert.NoError(t, err)
  41         }
  42 }
  43
  44 func Test_bucket_cannot_empty(t *testing.T) {
  45
  46         endpoint := "play.min.io:9000"
  47         accessKey := "Q3AM3UQ867SPQQA43P2F"
  48         secretKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"
  49
  50         minioClient, err := minio.New(endpoint, &minio.Options{
  51                 Creds:  credentials.NewStaticV4(accessKey, secretKey, ""),
  52                 Secure: true,
  53         })
  54         if err != nil {
  55                 log.Fatalf("Error creating Minio client: %v", err)
  56         }
  57
  58         if _, err := minioClient.ListBuckets(context.Background()); err != nil {
  59                 log.Fatalf("Error connecting to Minio server: %v", err)
  60         }
  61
  62         // Create a test bucket.
  63         bucketName := ""
  64         err = create_minio_bucket(minioClient, bucketName)
  65         if err != nil {
  66                 assert.Error(t, err)
  67         } else {
  68                 assert.NoError(t, err)
  69         }
  70 }
  71
  72 func Test_check_minio_bucket(t *testing.T) {
  73
  74         endpoint := "play.min.io:9000"
  75         accessKey := "Q3AM3UQ867SPQQA43P2F"
  76         secretKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"
  77
  78         found := false
  79
  80         minioClient, err := minio.New(endpoint, &minio.Options{
  81                 Creds:  credentials.NewStaticV4(accessKey, secretKey, ""),
  82                 Secure: true,
  83         })
  84         if err != nil {
  85                 log.Fatalf("Error creating Minio client: %v", err)
  86         }
  87
  88         if _, err := minioClient.ListBuckets(context.Background()); err != nil {
  89                 log.Fatalf("Error connecting to Minio server: %v", err)
  90         }
  91
  92         // Create a test bucket.
  93         bucketName := "my-test-bucket"
  94         found = check_minio_bucket(minioClient, bucketName)
  95         if found {
  96                 assert.True(t, found)
  97         } else {
  98                 assert.False(t, found)
  99         }
 100 }
 101
 102 func Test_bucket_not_exists(t *testing.T) {
 103
 104         endpoint := "play.min.io:9000"
 105         accessKey := "Q3AM3UQ867SPQQA43P2F"
 106         secretKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"
 107
 108         found := false
 109
 110         minioClient, err := minio.New(endpoint, &minio.Options{
 111                 Creds:  credentials.NewStaticV4(accessKey, secretKey, ""),
 112                 Secure: true,
 113         })
 114         if err != nil {
 115                 log.Fatalf("Error creating Minio client: %v", err)
 116         }
 117
 118         if _, err := minioClient.ListBuckets(context.Background()); err != nil {
 119                 log.Fatalf("Error connecting to Minio server: %v", err)
 120         }
 121
 122         // Create a test bucket.
 123         bucketName := "my-test-bucket-not-exists"
 124         found = check_minio_bucket(minioClient, bucketName)
 125         if found {
 126                 assert.True(t, found)
 127         } else {
 128                 assert.False(t, found)
 129         }
 130 }
 131
 132 func Test_upload_object(t *testing.T) {
 133
 134         endpoint := "play.min.io:9000"
 135         accessKey := "Q3AM3UQ867SPQQA43P2F"
 136         secretKey := "zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG"
 137
 138         minioClient, err := minio.New(endpoint, &minio.Options{
 139                 Creds:  credentials.NewStaticV4(accessKey, secretKey, ""),
 140                 Secure: true,
 141         })
 142         if err != nil {
 143                 log.Fatalf("Error creating Minio client: %v", err)
 144         }
 145
 146         if _, err := minioClient.ListBuckets(context.Background()); err != nil {
 147                 log.Fatalf("Error connecting to Minio server: %v", err)
 148         }
 149
 150         json_filename := "minio_upload_test.json"
 151
 152         fi, err := os.Open(json_filename)
 153
 154         if err != nil {
 155                 t.Fatalf("File %s - cannot be opened  - discarding message, error details: %s", json_filename, err.Error())
 156         }
 157         defer fi.Close()
 158
 159         reader := fi
 160
 161         var buf3 bytes.Buffer
 162         _, err2 := io.Copy(&buf3, reader)
 163         if err2 != nil {
 164                 t.Fatalf("File %s - cannot be read, discarding message, %s", json_filename, err.Error())
 165                 return
 166         }
 167         file_bytes := buf3.Bytes()
 168
 169         // Create a test bucket.
 170         bucketName := "my-test-bucket"
 171         upload_object(minioClient, file_bytes, "minio_upload_test.json", bucketName)
 172
 173         assert.NoError(t, err)
 174
 175 }