vnfs/DAaaS/microservices/prom-kafka-writer/pkg/kafkawriter/kafkawriter_test.go

   1 /*
   2  *
   3  * Copyright 2019 Intel Corporation.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  * Unless required by applicable law or agreed to in writing, software
   9  * distributed under the License is distributed on an "AS IS" BASIS,
  10  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11  * See the License for the specific language governing permissions and
  12  * limitations under the License.
  13  *
  14  */
  15
  16 package kafkawriter
  17
  18 import (
  19         "github.com/stretchr/testify/assert"
  20         "reflect"
  21         "testing"
  22 )
  23
  24 func TestNewKafkaWriter(t *testing.T) {
  25         type args struct {
  26                 kwc *KWConfig
  27         }
  28         kwc := NewKWConfig()
  29         kwc.Broker = "localhost:9092"
  30         kwc.Topic = "metrics"
  31
  32         kwc2 := NewKWConfig()
  33         kwc2.Broker = "localhost:9092"
  34         kwc2.Topic = "metrics"
  35         kwc2.BatchMsgNum = 0
  36
  37         tests := []struct {
  38                 name string
  39                 args args
  40                 want interface{}
  41         }{
  42                 {
  43                         name: "Test New Kafka Writer",
  44                         args: args{kwc},
  45                         want: "rdkafka#producer-1",
  46                 },
  47                 {
  48                         name: "Test New Kafka Writer Wrong Config",
  49                         args: args{kwc2},
  50                         want: nil,
  51                 },
  52         }
  53         for _, tt := range tests {
  54                 t.Run(tt.name, func(t *testing.T) {
  55                         got, _ := NewKafkaWriter(tt.args.kwc)
  56                         if tt.want == nil {
  57                                 assert.Equal(t, tt.want, nil)
  58                         } else {
  59                                 if !reflect.DeepEqual(got.String(), tt.want) {
  60                                         t.Errorf("NewKafkaWriter() = %v, want %v", got, tt.want)
  61                                 }
  62                         }
  63                 })
  64         }
  65 }
  66
  67 func TestNewKWConfig(t *testing.T) {
  68         tests := []struct {
  69                 name string
  70                 want *KWConfig
  71         }{
  72                 {
  73                         name: "Test New Kafka Config",
  74                         want: &KWConfig{
  75                                 UsePartition: false,
  76                                 BatchMsgNum:  10000,
  77                                 Compression:  "none",
  78                         },
  79                 },
  80         }
  81         for _, tt := range tests {
  82                 t.Run(tt.name, func(t *testing.T) {
  83                         if got := NewKWConfig(); !reflect.DeepEqual(got, tt.want) {
  84                                 t.Errorf("NewKWConfig() = %v, want %v", got, tt.want)
  85                         }
  86                 })
  87         }
  88 }
  89
  90 func TestAddKWC(t *testing.T) {
  91         type args struct {
  92                 kwc *KWConfig
  93         }
  94         kwc := NewKWConfig()
  95         kwc.Broker = "localhost:9092"
  96         kwc.Topic = "metrics"
  97         tests := []struct {
  98                 name string
  99                 args args
 100                 want string
 101         }{
 102                 {
 103                         name: "Test Add Kafka Writer 1",
 104                         args: args{kwc},
 105                         want: "pkw0",
 106                 },
 107                 {
 108                         name: "Test Add Kafka Writer 2 ",
 109                         args: args{kwc},
 110                         want: "pkw1",
 111                 },
 112         }
 113         for _, tt := range tests {
 114                 t.Run(tt.name, func(t *testing.T) {
 115                         got, _ := AddKWC(tt.args.kwc)
 116                         assert.Equal(t, tt.want, got)
 117
 118                 })
 119         }
 120         assert.Equal(t, 2, len(KWMap))
 121 }
 122
 123 func TestDeleteKWC(t *testing.T) {
 124         type args struct {
 125                 kwid string
 126         }
 127         tests := []struct {
 128                 name     string
 129                 args     args
 130                 delcount int
 131         }{
 132                 {
 133                         name:     "Test Delete Kafka Writer 1",
 134                         args:     args{"pkw0"},
 135                         delcount: 1,
 136                 },
 137                 {
 138                         name:     "Test Delete Kafka Writer Non existent",
 139                         args:     args{"pkw3"},
 140                         delcount: 0,
 141                 },
 142                 {
 143                         name:     "Test Delete Kafka Writer 2",
 144                         args:     args{"pkw1"},
 145                         delcount: 1,
 146                 },
 147         }
 148         for _, tt := range tests {
 149                 l := len(KWMap)
 150                 t.Run(tt.name, func(t *testing.T) {
 151                         DeleteKWC(tt.args.kwid)
 152                 })
 153                 assert.Equal(t, l-tt.delcount, len(KWMap))
 154         }
 155         assert.Equal(t, 0, len(KWMap))
 156 }
 157
 158 func TestListKWC(t *testing.T) {
 159         tests := []struct {
 160                 name  string
 161                 init  func() string
 162                 want  KWRespMap
 163                 clean func(string)
 164         }{
 165                 {
 166                         name: "Test List Kafka Writers Empty",
 167                         want: KWRespMap{"pkw2": {
 168                                 Broker:       "localhost:9092",
 169                                 Topic:        "metrics",
 170                                 UsePartition: false,
 171                                 BatchMsgNum:  10000,
 172                                 Compression:  "none",
 173                         }},
 174                         init: func() string {
 175                                 kwc := NewKWConfig()
 176                                 kwc.Broker = "localhost:9092"
 177                                 kwc.Topic = "metrics"
 178                                 id, _ := AddKWC(kwc)
 179                                 return id
 180                         },
 181                         clean: func(id string) {
 182                                 DeleteKWC(id)
 183                         },
 184                 },
 185                 {
 186                         name: "Test List Kafka Writers Empty",
 187                         want: KWRespMap{},
 188                         init: func() string {
 189                                 return ""
 190                         },
 191                         clean: func(string) {},
 192                 },
 193         }
 194         for _, tt := range tests {
 195                 id := tt.init()
 196                 t.Run(tt.name, func(t *testing.T) {
 197                         if got := ListKWC(); !reflect.DeepEqual(got, tt.want) {
 198                                 t.Errorf("ListKWC() = %v, want %v", got, tt.want)
 199                         }
 200                 })
 201                 tt.clean(id)
 202         }
 203 }
 204
 205 func TestCleanup(t *testing.T) {
 206         tests := []struct {
 207                 name string
 208                 init func()
 209         }{
 210                 {
 211                         name: "Test List Kafka Writers Empty",
 212                         init: func() {
 213                                 kwc := NewKWConfig()
 214                                 kwc.Broker = "localhost:9092"
 215                                 kwc.Topic = "metrics"
 216                                 AddKWC(kwc)
 217                                 AddKWC(kwc)
 218                                 AddKWC(kwc)
 219                         },
 220                 },
 221         }
 222         for _, tt := range tests {
 223                 tt.init()
 224                 t.Run(tt.name, func(t *testing.T) {
 225                         Cleanup()
 226                 })
 227                 assert.Equal(t, 0, len(KWMap))
 228         }
 229 }