github.com/aiven/aiven-go-client@v1.36.0/kafka_schemas_test.go (about)

     1  package aiven
     2  
     3  import (
     4  	"encoding/json"
     5  	"net/http"
     6  	"net/http/httptest"
     7  	"reflect"
     8  	"testing"
     9  )
    10  
    11  func setupKafkaSchemasTestCase(t *testing.T) (*Client, func(t *testing.T)) {
    12  	t.Log("setup Kafka Schemas test case")
    13  
    14  	const (
    15  		UserName     = "test@aiven.io"
    16  		UserPassword = "testabcd"
    17  		AccessToken  = "some-random-token"
    18  	)
    19  
    20  	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    21  		// auth
    22  		if r.URL.Path == "/userauth" {
    23  			w.Header().Set("Content-Type", "application/json")
    24  			w.WriteHeader(http.StatusOK)
    25  			err := json.NewEncoder(w).Encode(authResponse{
    26  				Token: AccessToken,
    27  				State: "active",
    28  			})
    29  
    30  			if err != nil {
    31  				t.Error(err)
    32  			}
    33  			return
    34  		}
    35  
    36  		// config
    37  		if r.URL.Path == "/project/test-pr/service/test-sr/kafka/schema/config" {
    38  			if r.Method == "PUT" {
    39  				w.Header().Set("Content-Type", "application/json")
    40  				w.WriteHeader(http.StatusOK)
    41  				err := json.NewEncoder(w).Encode(KafkaSchemaConfigUpdateResponse{
    42  					APIResponse{},
    43  					KafkaSchemaConfig{CompatibilityLevel: "FULL"},
    44  				})
    45  
    46  				if err != nil {
    47  					t.Error(err)
    48  				}
    49  			}
    50  
    51  			if r.Method == "GET" {
    52  				w.Header().Set("Content-Type", "application/json")
    53  				w.WriteHeader(http.StatusOK)
    54  				err := json.NewEncoder(w).Encode(KafkaSchemaConfigResponse{
    55  					CompatibilityLevel: "FULL",
    56  				})
    57  
    58  				if err != nil {
    59  					t.Error(err)
    60  				}
    61  			}
    62  
    63  			return
    64  		}
    65  
    66  		// config
    67  		if r.URL.Path == "/project/test-pr/service/test-sr/kafka/schema/config" {
    68  			w.Header().Set("Content-Type", "application/json")
    69  			w.WriteHeader(http.StatusOK)
    70  			err := json.NewEncoder(w).Encode(KafkaSchemaConfigResponse{
    71  				CompatibilityLevel: "FULL",
    72  			})
    73  
    74  			if err != nil {
    75  				t.Error(err)
    76  			}
    77  
    78  			return
    79  		}
    80  
    81  		// subjects
    82  		if r.URL.Path == "/project/test-pr/service/test-sr/kafka/schema/subjects" {
    83  			w.Header().Set("Content-Type", "application/json")
    84  			w.WriteHeader(http.StatusOK)
    85  			err := json.NewEncoder(w).Encode(KafkaSchemaSubjectsResponse{
    86  				APIResponse{},
    87  				KafkaSchemaSubjects{Subjects: []string{"testSb1", "testSb2"}},
    88  			})
    89  
    90  			if err != nil {
    91  				t.Error(err)
    92  			}
    93  
    94  			return
    95  		}
    96  
    97  		// add subject no versions
    98  		if r.URL.Path == "/project/test-pr/service/test-sr/kafka/schema/subjects/test-schema-no-versions/versions" {
    99  			if r.Method == "GET" {
   100  				w.Header().Set("Content-Type", "application/json")
   101  				w.WriteHeader(http.StatusNotFound)
   102  
   103  				return
   104  			}
   105  
   106  			if r.Method == "POST" {
   107  				w.Header().Set("Content-Type", "application/json")
   108  				w.WriteHeader(http.StatusOK)
   109  
   110  				err := json.NewEncoder(w).Encode(KafkaSchemaSubjectResponse{
   111  					APIResponse{},
   112  					1,
   113  				})
   114  
   115  				if err != nil {
   116  					t.Error(err)
   117  				}
   118  
   119  				return
   120  			}
   121  		}
   122  
   123  		// add subject has versions
   124  		if r.URL.Path == "/project/test-pr/service/test-sr/kafka/schema/subjects/test-schema/versions" {
   125  			if r.Method == "GET" {
   126  				w.Header().Set("Content-Type", "application/json")
   127  				w.WriteHeader(http.StatusOK)
   128  
   129  				err := json.NewEncoder(w).Encode(KafkaSchemaSubjectVersionsResponse{
   130  					APIResponse{},
   131  					KafkaSchemaSubjectVersions{Versions: []int{1, 2, 3, 4}},
   132  				})
   133  
   134  				if err != nil {
   135  					t.Error(err)
   136  				}
   137  
   138  				return
   139  			}
   140  
   141  			if r.Method == "POST" {
   142  				w.Header().Set("Content-Type", "application/json")
   143  				w.WriteHeader(http.StatusOK)
   144  
   145  				err := json.NewEncoder(w).Encode(KafkaSchemaSubjectResponse{
   146  					APIResponse{},
   147  					5,
   148  				})
   149  
   150  				if err != nil {
   151  					t.Error(err)
   152  				}
   153  
   154  				return
   155  			}
   156  		}
   157  
   158  		// validate against version 4
   159  		if r.URL.Path == "/project/test-pr/service/test-sr/kafka/schema/compatibility/subjects/test-schema/versions/4" {
   160  			w.Header().Set("Content-Type", "application/json")
   161  			w.WriteHeader(http.StatusOK)
   162  			err := json.NewEncoder(w).Encode(KafkaSchemaValidateResponse{
   163  				APIResponse{},
   164  				true,
   165  			})
   166  
   167  			if err != nil {
   168  				t.Error(err)
   169  			}
   170  
   171  			return
   172  		}
   173  
   174  		if r.URL.Path == "/project/test-pr/service/test-sr/kafka/schema/subjects/test-schema/versions/5" {
   175  			if r.Method == "DELETE" {
   176  				w.Header().Set("Content-Type", "application/json")
   177  				w.WriteHeader(http.StatusOK)
   178  
   179  				err := json.NewEncoder(w).Encode(APIResponse{})
   180  
   181  				if err != nil {
   182  					t.Error(err)
   183  				}
   184  
   185  				return
   186  			}
   187  
   188  			if r.Method == "GET" {
   189  				w.Header().Set("Content-Type", "application/json")
   190  				w.WriteHeader(http.StatusOK)
   191  
   192  				err := json.NewEncoder(w).Encode(KafkaSchemaSubjectVersionResponse{
   193  					APIResponse: APIResponse{},
   194  					Version: KafkaSchemaSubjectVersion{
   195  						Id:      5,
   196  						Schema:  "",
   197  						Subject: "est-schema",
   198  						Version: 5,
   199  					},
   200  				})
   201  
   202  				if err != nil {
   203  					t.Error(err)
   204  				}
   205  
   206  				return
   207  			}
   208  		}
   209  
   210  	}))
   211  
   212  	apiUrl = ts.URL
   213  
   214  	c, err := NewUserClient(UserName, UserPassword, "aiven-go-client-test/"+Version())
   215  	if err != nil {
   216  		t.Fatalf("user authentication error: %s", err)
   217  	}
   218  
   219  	return c, func(t *testing.T) {
   220  		t.Log("teardown ElasticsearchACLs test case")
   221  		ts.Close()
   222  	}
   223  }
   224  
   225  func TestKafkaGlobalSchemaConfigHandler_Update(t *testing.T) {
   226  	c, tearDown := setupKafkaSchemasTestCase(t)
   227  	defer tearDown(t)
   228  
   229  	type fields struct {
   230  		client *Client
   231  	}
   232  	type args struct {
   233  		project string
   234  		service string
   235  		c       KafkaSchemaConfig
   236  	}
   237  	tests := []struct {
   238  		name    string
   239  		fields  fields
   240  		args    args
   241  		want    *KafkaSchemaConfigUpdateResponse
   242  		wantErr bool
   243  	}{
   244  		{
   245  			"",
   246  			fields{client: c},
   247  			args{
   248  				project: "test-pr",
   249  				service: "test-sr",
   250  				c: KafkaSchemaConfig{
   251  					CompatibilityLevel: "FULL",
   252  				},
   253  			},
   254  			&KafkaSchemaConfigUpdateResponse{
   255  				APIResponse: APIResponse{},
   256  				KafkaSchemaConfig: KafkaSchemaConfig{
   257  					CompatibilityLevel: "FULL",
   258  				},
   259  			},
   260  			false,
   261  		},
   262  	}
   263  	for _, tt := range tests {
   264  		t.Run(tt.name, func(t *testing.T) {
   265  			h := &KafkaGlobalSchemaConfigHandler{
   266  				client: tt.fields.client,
   267  			}
   268  			got, err := h.Update(tt.args.project, tt.args.service, tt.args.c)
   269  			if (err != nil) != tt.wantErr {
   270  				t.Errorf("UpdateConfig() error = %v, wantErr %v", err, tt.wantErr)
   271  				return
   272  			}
   273  			if !reflect.DeepEqual(got, tt.want) {
   274  				t.Errorf("UpdateConfig() got = %v, want %v", got, tt.want)
   275  			}
   276  		})
   277  	}
   278  }
   279  
   280  func TestKafkaSchemaHandler_Add(t *testing.T) {
   281  	c, tearDown := setupKafkaSchemasTestCase(t)
   282  	defer tearDown(t)
   283  
   284  	schema := `
   285  		{
   286  				"doc": "example",
   287  				"fields": [{
   288  					"default": 5,
   289  					"doc": "my test number",
   290  					"name": "test",
   291  					"namespace": "test",
   292  					"type": "int"
   293  				}],
   294  				"name": "example",
   295  				"namespace": "example",
   296  				"type": "record"
   297  			}`
   298  
   299  	type fields struct {
   300  		client *Client
   301  	}
   302  	type args struct {
   303  		project string
   304  		service string
   305  		name    string
   306  		subject KafkaSchemaSubject
   307  	}
   308  	tests := []struct {
   309  		name    string
   310  		fields  fields
   311  		args    args
   312  		want    *KafkaSchemaSubjectResponse
   313  		wantErr bool
   314  	}{
   315  		{
   316  			"no-versions",
   317  			fields{client: c},
   318  			args{
   319  				project: "test-pr",
   320  				service: "test-sr",
   321  				name:    "test-schema-no-versions",
   322  				subject: KafkaSchemaSubject{Schema: schema},
   323  			},
   324  			&KafkaSchemaSubjectResponse{
   325  				Id: 1,
   326  			},
   327  			false,
   328  		},
   329  		{
   330  			"has-versions",
   331  			fields{client: c},
   332  			args{
   333  				project: "test-pr",
   334  				service: "test-sr",
   335  				name:    "test-schema",
   336  				subject: KafkaSchemaSubject{Schema: schema},
   337  			},
   338  			&KafkaSchemaSubjectResponse{
   339  				Id: 5,
   340  			},
   341  			false,
   342  		},
   343  	}
   344  	for _, tt := range tests {
   345  		t.Run(tt.name, func(t *testing.T) {
   346  			h := &KafkaSubjectSchemasHandler{
   347  				client: tt.fields.client,
   348  			}
   349  			got, err := h.Add(tt.args.project, tt.args.service, tt.args.name, tt.args.subject)
   350  			if (err != nil) != tt.wantErr {
   351  				t.Errorf("Add() error = %v, wantErr %v", err, tt.wantErr)
   352  				return
   353  			}
   354  			if !reflect.DeepEqual(got, tt.want) {
   355  				t.Errorf("Add() got = %v, want %v", got, tt.want)
   356  			}
   357  		})
   358  	}
   359  }
   360  
   361  func TestKafkaSchemaHandler_Delete(t *testing.T) {
   362  	c, tearDown := setupKafkaSchemasTestCase(t)
   363  	defer tearDown(t)
   364  
   365  	type fields struct {
   366  		client *Client
   367  	}
   368  	type args struct {
   369  		project string
   370  		service string
   371  		name    string
   372  		version int
   373  	}
   374  	tests := []struct {
   375  		name    string
   376  		fields  fields
   377  		args    args
   378  		wantErr bool
   379  	}{
   380  		{
   381  			"",
   382  			fields{client: c},
   383  			args{
   384  				project: "test-pr",
   385  				service: "test-sr",
   386  				name:    "test-schema",
   387  				version: 5,
   388  			},
   389  			false,
   390  		},
   391  	}
   392  	for _, tt := range tests {
   393  		t.Run(tt.name, func(t *testing.T) {
   394  			h := &KafkaSubjectSchemasHandler{
   395  				client: tt.fields.client,
   396  			}
   397  			if err := h.Delete(tt.args.project, tt.args.service, tt.args.name, tt.args.version); (err != nil) != tt.wantErr {
   398  				t.Errorf("Delete() error = %v, wantErr %v", err, tt.wantErr)
   399  			}
   400  		})
   401  	}
   402  }
   403  
   404  func TestKafkaGlobalSchemaConfigHandler_Get(t *testing.T) {
   405  	c, tearDown := setupKafkaSchemasTestCase(t)
   406  	defer tearDown(t)
   407  
   408  	type fields struct {
   409  		client *Client
   410  	}
   411  	type args struct {
   412  		project string
   413  		service string
   414  	}
   415  	tests := []struct {
   416  		name    string
   417  		fields  fields
   418  		args    args
   419  		want    *KafkaSchemaConfigResponse
   420  		wantErr bool
   421  	}{
   422  		{
   423  			"",
   424  			fields{client: c},
   425  			args{
   426  				project: "test-pr",
   427  				service: "test-sr",
   428  			},
   429  			&KafkaSchemaConfigResponse{
   430  				APIResponse:        APIResponse{},
   431  				CompatibilityLevel: "FULL",
   432  			},
   433  			false,
   434  		},
   435  	}
   436  	for _, tt := range tests {
   437  		t.Run(tt.name, func(t *testing.T) {
   438  			h := &KafkaGlobalSchemaConfigHandler{
   439  				client: tt.fields.client,
   440  			}
   441  			got, err := h.Get(tt.args.project, tt.args.service)
   442  			if (err != nil) != tt.wantErr {
   443  				t.Errorf("GetConfig() error = %v, wantErr %v", err, tt.wantErr)
   444  				return
   445  			}
   446  			if !reflect.DeepEqual(got, tt.want) {
   447  				t.Errorf("GetConfig() got = %v, want %v", got, tt.want)
   448  			}
   449  		})
   450  	}
   451  }
   452  
   453  func TestKafkaSchemaHandler_Get(t *testing.T) {
   454  	c, tearDown := setupKafkaSchemasTestCase(t)
   455  	defer tearDown(t)
   456  
   457  	type fields struct {
   458  		client *Client
   459  	}
   460  	type args struct {
   461  		project string
   462  		service string
   463  		name    string
   464  		version int
   465  	}
   466  	tests := []struct {
   467  		name    string
   468  		fields  fields
   469  		args    args
   470  		want    *KafkaSchemaSubjectVersionResponse
   471  		wantErr bool
   472  	}{
   473  		{
   474  			"",
   475  			fields{client: c},
   476  			args{
   477  				project: "test-pr",
   478  				service: "test-sr",
   479  				name:    "test-schema",
   480  				version: 5,
   481  			},
   482  			&KafkaSchemaSubjectVersionResponse{
   483  				APIResponse: APIResponse{},
   484  				Version: KafkaSchemaSubjectVersion{
   485  					Id:      5,
   486  					Schema:  "",
   487  					Subject: "est-schema",
   488  					Version: 5,
   489  				},
   490  			},
   491  			false,
   492  		},
   493  	}
   494  	for _, tt := range tests {
   495  		t.Run(tt.name, func(t *testing.T) {
   496  			h := &KafkaSubjectSchemasHandler{
   497  				client: tt.fields.client,
   498  			}
   499  			got, err := h.Get(tt.args.project, tt.args.service, tt.args.name, tt.args.version)
   500  			if (err != nil) != tt.wantErr {
   501  				t.Errorf("Get() error = %v, wantErr %v", err, tt.wantErr)
   502  				return
   503  			}
   504  			if !reflect.DeepEqual(got, tt.want) {
   505  				t.Errorf("Get() got = %v, want %v", got, tt.want)
   506  			}
   507  		})
   508  	}
   509  }
   510  
   511  func TestKafkaSchemaHandler_GetVersions(t *testing.T) {
   512  	c, tearDown := setupKafkaSchemasTestCase(t)
   513  	defer tearDown(t)
   514  
   515  	type fields struct {
   516  		client *Client
   517  	}
   518  	type args struct {
   519  		project string
   520  		service string
   521  		name    string
   522  	}
   523  	tests := []struct {
   524  		name    string
   525  		fields  fields
   526  		args    args
   527  		want    *KafkaSchemaSubjectVersionsResponse
   528  		wantErr bool
   529  	}{
   530  		{
   531  			"",
   532  			fields{client: c},
   533  			args{
   534  				project: "test-pr",
   535  				service: "test-sr",
   536  				name:    "test-schema",
   537  			},
   538  			&KafkaSchemaSubjectVersionsResponse{
   539  				APIResponse: APIResponse{},
   540  				KafkaSchemaSubjectVersions: KafkaSchemaSubjectVersions{
   541  					Versions: []int{1, 2, 3, 4},
   542  				},
   543  			},
   544  			false,
   545  		},
   546  	}
   547  	for _, tt := range tests {
   548  		t.Run(tt.name, func(t *testing.T) {
   549  			h := &KafkaSubjectSchemasHandler{
   550  				client: tt.fields.client,
   551  			}
   552  			got, err := h.GetVersions(tt.args.project, tt.args.service, tt.args.name)
   553  			if (err != nil) != tt.wantErr {
   554  				t.Errorf("GetVersions() error = %v, wantErr %v", err, tt.wantErr)
   555  				return
   556  			}
   557  			if !reflect.DeepEqual(got, tt.want) {
   558  				t.Errorf("GetVersions() got = %v, want %v", got, tt.want)
   559  			}
   560  		})
   561  	}
   562  }
   563  
   564  func TestKafkaSchemaHandler_List(t *testing.T) {
   565  	c, tearDown := setupKafkaSchemasTestCase(t)
   566  	defer tearDown(t)
   567  
   568  	type fields struct {
   569  		client *Client
   570  	}
   571  	type args struct {
   572  		project string
   573  		service string
   574  	}
   575  	tests := []struct {
   576  		name    string
   577  		fields  fields
   578  		args    args
   579  		want    *KafkaSchemaSubjectsResponse
   580  		wantErr bool
   581  	}{
   582  		{
   583  			"",
   584  			fields{client: c},
   585  			args{
   586  				project: "test-pr",
   587  				service: "test-sr",
   588  			},
   589  			&KafkaSchemaSubjectsResponse{
   590  				APIResponse: APIResponse{},
   591  				KafkaSchemaSubjects: KafkaSchemaSubjects{
   592  					Subjects: []string{"testSb1", "testSb2"},
   593  				},
   594  			},
   595  			false,
   596  		},
   597  	}
   598  	for _, tt := range tests {
   599  		t.Run(tt.name, func(t *testing.T) {
   600  			h := &KafkaSubjectSchemasHandler{
   601  				client: tt.fields.client,
   602  			}
   603  			got, err := h.List(tt.args.project, tt.args.service)
   604  			if (err != nil) != tt.wantErr {
   605  				t.Errorf("List() error = %v, wantErr %v", err, tt.wantErr)
   606  				return
   607  			}
   608  			if !reflect.DeepEqual(got, tt.want) {
   609  				t.Errorf("List() got = %v, want %v", got, tt.want)
   610  			}
   611  		})
   612  	}
   613  }
   614  
   615  func TestKafkaSchemaHandler_Validate(t *testing.T) {
   616  	c, tearDown := setupKafkaSchemasTestCase(t)
   617  	defer tearDown(t)
   618  
   619  	type fields struct {
   620  		client *Client
   621  	}
   622  	type args struct {
   623  		project string
   624  		service string
   625  		name    string
   626  		version int
   627  		subject KafkaSchemaSubject
   628  	}
   629  	tests := []struct {
   630  		name    string
   631  		fields  fields
   632  		args    args
   633  		want    bool
   634  		wantErr bool
   635  	}{
   636  		{
   637  			"",
   638  			fields{client: c},
   639  			args{
   640  				project: "test-pr",
   641  				service: "test-sr",
   642  				name:    "test-schema",
   643  				version: 4,
   644  				subject: KafkaSchemaSubject{Schema: `
   645  				{
   646  					"doc": "example",
   647  					"fields": [{
   648  						"default": 5,
   649  						"doc": "my test number",
   650  						"name": "test",
   651  						"namespace": "test",
   652  						"type": "int"
   653  					}],
   654  					"name": "example",
   655  					"namespace": "example",
   656  					"type": "record"
   657  				}`},
   658  			},
   659  			true,
   660  			false,
   661  		},
   662  	}
   663  	for _, tt := range tests {
   664  		t.Run(tt.name, func(t *testing.T) {
   665  			h := &KafkaSubjectSchemasHandler{
   666  				client: tt.fields.client,
   667  			}
   668  			got, err := h.Validate(tt.args.project, tt.args.service, tt.args.name, tt.args.version, tt.args.subject)
   669  			if (err != nil) != tt.wantErr {
   670  				t.Errorf("Validate() error = %v, wantErr %v", err, tt.wantErr)
   671  				return
   672  			}
   673  			if got != tt.want {
   674  				t.Errorf("Validate() got = %v, want %v", got, tt.want)
   675  			}
   676  		})
   677  	}
   678  }