github.com/cs3org/reva/v2@v2.27.7/pkg/app/registry/static/static_test.go (about)

     1  // Copyright 2018-2021 CERN
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  //
    15  // In applying this license, CERN does not waive the privileges and immunities
    16  // granted to it by virtue of its status as an Intergovernmental Organization
    17  // or submit itself to any jurisdiction.
    18  
    19  package static
    20  
    21  import (
    22  	"context"
    23  	"reflect"
    24  	"testing"
    25  
    26  	registrypb "github.com/cs3org/go-cs3apis/cs3/app/registry/v1beta1"
    27  	typesv1beta1 "github.com/cs3org/go-cs3apis/cs3/types/v1beta1"
    28  	"github.com/cs3org/reva/v2/pkg/errtypes"
    29  )
    30  
    31  func TestFindProviders(t *testing.T) {
    32  
    33  	testCases := []struct {
    34  		name         string
    35  		mimeTypes    []*mimeTypeConfig
    36  		regProviders []*registrypb.ProviderInfo
    37  		mimeType     string
    38  		expectedRes  []*registrypb.ProviderInfo
    39  		expectedErr  error
    40  	}{
    41  		{
    42  			name:        "no mime types registered",
    43  			mimeTypes:   []*mimeTypeConfig{},
    44  			mimeType:    "SOMETHING",
    45  			expectedErr: errtypes.NotFound("application provider not found for mime type SOMETHING"),
    46  		},
    47  		{
    48  			name: "one provider registered for one mime type",
    49  			mimeTypes: []*mimeTypeConfig{
    50  				{
    51  					MimeType:   "text/json",
    52  					Extension:  "json",
    53  					Name:       "JSON File",
    54  					Icon:       "https://example.org/icons&file=json.png",
    55  					DefaultApp: "some Address",
    56  				},
    57  			},
    58  			regProviders: []*registrypb.ProviderInfo{
    59  				{
    60  					MimeTypes: []string{"text/json"},
    61  					Address:   "some Address",
    62  					Name:      "some Name",
    63  				},
    64  			},
    65  			mimeType:    "text/json",
    66  			expectedErr: nil,
    67  			expectedRes: []*registrypb.ProviderInfo{
    68  				{
    69  					MimeTypes: []string{"text/json"},
    70  					Address:   "some Address",
    71  					Name:      "some Name",
    72  				},
    73  			},
    74  		},
    75  		{
    76  			name: "more providers registered for one mime type",
    77  			mimeTypes: []*mimeTypeConfig{
    78  				{
    79  					MimeType:   "text/json",
    80  					Extension:  "json",
    81  					Name:       "JSON File",
    82  					Icon:       "https://example.org/icons&file=json.png",
    83  					DefaultApp: "provider2",
    84  				},
    85  			},
    86  			regProviders: []*registrypb.ProviderInfo{
    87  				{
    88  					MimeTypes: []string{"text/json"},
    89  					Address:   "ip-provider1",
    90  					Name:      "provider1",
    91  				},
    92  				{
    93  					MimeTypes: []string{"text/json"},
    94  					Address:   "ip-provider2",
    95  					Name:      "provider2",
    96  				},
    97  				{
    98  					MimeTypes: []string{"text/json"},
    99  					Address:   "ip-provider3",
   100  					Name:      "provider3",
   101  				},
   102  			},
   103  			mimeType:    "text/json",
   104  			expectedErr: nil,
   105  			expectedRes: []*registrypb.ProviderInfo{
   106  				{
   107  					MimeTypes: []string{"text/json"},
   108  					Address:   "ip-provider1",
   109  					Name:      "provider1",
   110  				},
   111  				{
   112  					MimeTypes: []string{"text/json"},
   113  					Address:   "ip-provider2",
   114  					Name:      "provider2",
   115  				},
   116  				{
   117  					MimeTypes: []string{"text/json"},
   118  					Address:   "ip-provider3",
   119  					Name:      "provider3",
   120  				},
   121  			},
   122  		},
   123  		{
   124  			name: "more providers registered for different mime types",
   125  			mimeTypes: []*mimeTypeConfig{
   126  				{
   127  					MimeType:   "text/json",
   128  					Extension:  "json",
   129  					Name:       "JSON File",
   130  					Icon:       "https://example.org/icons&file=json.png",
   131  					DefaultApp: "provider2",
   132  				},
   133  				{
   134  					MimeType:   "text/xml",
   135  					Extension:  "xml",
   136  					Name:       "XML File",
   137  					Icon:       "https://example.org/icons&file=xml.png",
   138  					DefaultApp: "provider1",
   139  				},
   140  			},
   141  			regProviders: []*registrypb.ProviderInfo{
   142  				{
   143  					MimeTypes: []string{"text/json", "text/xml"},
   144  					Address:   "ip-provider1",
   145  					Name:      "provider1",
   146  				},
   147  				{
   148  					MimeTypes: []string{"text/json"},
   149  					Address:   "ip-provider2",
   150  					Name:      "provider2",
   151  				},
   152  				{
   153  					MimeTypes: []string{"text/xml"},
   154  					Address:   "ip-provider3",
   155  					Name:      "provider3",
   156  				},
   157  			},
   158  			mimeType:    "text/json",
   159  			expectedErr: nil,
   160  			expectedRes: []*registrypb.ProviderInfo{
   161  				{
   162  					MimeTypes: []string{"text/json", "text/xml"},
   163  					Address:   "ip-provider1",
   164  					Name:      "provider1",
   165  				},
   166  				{
   167  					MimeTypes: []string{"text/json"},
   168  					Address:   "ip-provider2",
   169  					Name:      "provider2",
   170  				},
   171  			},
   172  		},
   173  	}
   174  
   175  	for _, tt := range testCases {
   176  
   177  		t.Run(tt.name, func(t *testing.T) {
   178  
   179  			ctx := context.TODO()
   180  
   181  			registry, err := New(map[string]interface{}{
   182  				"mime_types": tt.mimeTypes,
   183  				"providers":  tt.regProviders,
   184  			})
   185  			if err != nil {
   186  				t.Error("unexpected error creating the registry:", err)
   187  			}
   188  
   189  			providers, err := registry.FindProviders(ctx, tt.mimeType)
   190  
   191  			// check that the error returned by FindProviders is the same as the expected
   192  			if tt.expectedErr != err {
   193  				t.Errorf("different error returned: got=%v expected=%v", err, tt.expectedErr)
   194  			}
   195  
   196  			if !providersEquals(providers, tt.expectedRes) {
   197  				t.Errorf("providers list different from expected: \n\tgot=%v\n\texp=%v", providers, tt.expectedRes)
   198  			}
   199  
   200  		})
   201  
   202  	}
   203  
   204  }
   205  
   206  func TestFindProvidersWithPriority(t *testing.T) {
   207  
   208  	testCases := []struct {
   209  		name         string
   210  		mimeTypes    []*mimeTypeConfig
   211  		regProviders []*registrypb.ProviderInfo
   212  		mimeType     string
   213  		expectedRes  []*registrypb.ProviderInfo
   214  		expectedErr  error
   215  	}{
   216  		{
   217  			name:        "no mime types registered",
   218  			mimeTypes:   []*mimeTypeConfig{},
   219  			mimeType:    "SOMETHING",
   220  			expectedErr: errtypes.NotFound("application provider not found for mime type SOMETHING"),
   221  		},
   222  		{
   223  			name: "one provider registered for one mime type",
   224  			mimeTypes: []*mimeTypeConfig{
   225  				{
   226  					MimeType:   "text/json",
   227  					Extension:  "json",
   228  					Name:       "JSON File",
   229  					Icon:       "https://example.org/icons&file=json.png",
   230  					DefaultApp: "some Address",
   231  				},
   232  			},
   233  			regProviders: []*registrypb.ProviderInfo{
   234  				{
   235  					MimeTypes: []string{"text/json"},
   236  					Address:   "some Address",
   237  					Name:      "some Name",
   238  					Opaque: &typesv1beta1.Opaque{
   239  						Map: map[string]*typesv1beta1.OpaqueEntry{
   240  							"priority": {
   241  								Decoder: "plain",
   242  								Value:   []byte("100"),
   243  							},
   244  						},
   245  					},
   246  				},
   247  			},
   248  			mimeType:    "text/json",
   249  			expectedErr: nil,
   250  			expectedRes: []*registrypb.ProviderInfo{
   251  				{
   252  					MimeTypes: []string{"text/json"},
   253  					Address:   "some Address",
   254  					Name:      "some Name",
   255  				},
   256  			},
   257  		},
   258  		{
   259  			name: "more providers registered for one mime type",
   260  			mimeTypes: []*mimeTypeConfig{
   261  				{
   262  					MimeType:   "text/json",
   263  					Extension:  "json",
   264  					Name:       "JSON File",
   265  					Icon:       "https://example.org/icons&file=json.png",
   266  					DefaultApp: "provider2",
   267  				},
   268  			},
   269  			regProviders: []*registrypb.ProviderInfo{
   270  				{
   271  					MimeTypes: []string{"text/json"},
   272  					Address:   "ip-provider1",
   273  					Name:      "provider1",
   274  					Opaque: &typesv1beta1.Opaque{
   275  						Map: map[string]*typesv1beta1.OpaqueEntry{
   276  							"priority": {
   277  								Decoder: "plain",
   278  								Value:   []byte("10"),
   279  							},
   280  						},
   281  					},
   282  				},
   283  				{
   284  					MimeTypes: []string{"text/json"},
   285  					Address:   "ip-provider2",
   286  					Name:      "provider2",
   287  					Opaque: &typesv1beta1.Opaque{
   288  						Map: map[string]*typesv1beta1.OpaqueEntry{
   289  							"priority": {
   290  								Decoder: "plain",
   291  								Value:   []byte("20"),
   292  							},
   293  						},
   294  					},
   295  				},
   296  				{
   297  					MimeTypes: []string{"text/json"},
   298  					Address:   "ip-provider3",
   299  					Name:      "provider3",
   300  					Opaque: &typesv1beta1.Opaque{
   301  						Map: map[string]*typesv1beta1.OpaqueEntry{
   302  							"priority": {
   303  								Decoder: "plain",
   304  								Value:   []byte("5"),
   305  							},
   306  						},
   307  					},
   308  				},
   309  			},
   310  			mimeType:    "text/json",
   311  			expectedErr: nil,
   312  			expectedRes: []*registrypb.ProviderInfo{
   313  				{
   314  					MimeTypes: []string{"text/json"},
   315  					Address:   "ip-provider2",
   316  					Name:      "provider2",
   317  				},
   318  				{
   319  					MimeTypes: []string{"text/json"},
   320  					Address:   "ip-provider1",
   321  					Name:      "provider1",
   322  				},
   323  				{
   324  					MimeTypes: []string{"text/json"},
   325  					Address:   "ip-provider3",
   326  					Name:      "provider3",
   327  				},
   328  			},
   329  		},
   330  		{
   331  			name: "more providers registered for different mime types",
   332  			mimeTypes: []*mimeTypeConfig{
   333  				{
   334  					MimeType:   "text/json",
   335  					Extension:  "json",
   336  					Name:       "JSON File",
   337  					Icon:       "https://example.org/icons&file=json.png",
   338  					DefaultApp: "provider2",
   339  				},
   340  				{
   341  					MimeType:   "text/xml",
   342  					Extension:  "xml",
   343  					Name:       "XML File",
   344  					Icon:       "https://example.org/icons&file=xml.png",
   345  					DefaultApp: "provider1",
   346  				},
   347  			},
   348  			regProviders: []*registrypb.ProviderInfo{
   349  				{
   350  					MimeTypes: []string{"text/json", "text/xml"},
   351  					Address:   "ip-provider1",
   352  					Name:      "provider1",
   353  					Opaque: &typesv1beta1.Opaque{
   354  						Map: map[string]*typesv1beta1.OpaqueEntry{
   355  							"priority": {
   356  								Decoder: "plain",
   357  								Value:   []byte("5"),
   358  							},
   359  						},
   360  					},
   361  				},
   362  				{
   363  					MimeTypes: []string{"text/json"},
   364  					Address:   "ip-provider2",
   365  					Name:      "provider2",
   366  					Opaque: &typesv1beta1.Opaque{
   367  						Map: map[string]*typesv1beta1.OpaqueEntry{
   368  							"priority": {
   369  								Decoder: "plain",
   370  								Value:   []byte("100"),
   371  							},
   372  						},
   373  					},
   374  				},
   375  				{
   376  					MimeTypes: []string{"text/xml"},
   377  					Address:   "ip-provider3",
   378  					Name:      "provider3",
   379  					Opaque: &typesv1beta1.Opaque{
   380  						Map: map[string]*typesv1beta1.OpaqueEntry{
   381  							"priority": {
   382  								Decoder: "plain",
   383  								Value:   []byte("20"),
   384  							},
   385  						},
   386  					},
   387  				},
   388  			},
   389  			mimeType:    "text/json",
   390  			expectedErr: nil,
   391  			expectedRes: []*registrypb.ProviderInfo{
   392  				{
   393  					MimeTypes: []string{"text/json"},
   394  					Address:   "ip-provider2",
   395  					Name:      "provider2",
   396  				},
   397  				{
   398  					MimeTypes: []string{"text/json", "text/xml"},
   399  					Address:   "ip-provider1",
   400  					Name:      "provider1",
   401  				},
   402  			},
   403  		},
   404  		{
   405  			name: "more providers registered for different mime types2",
   406  			mimeTypes: []*mimeTypeConfig{
   407  				{
   408  					MimeType:   "text/json",
   409  					Extension:  "json",
   410  					Name:       "JSON File",
   411  					Icon:       "https://example.org/icons&file=json.png",
   412  					DefaultApp: "provider2",
   413  				},
   414  				{
   415  					MimeType:   "text/xml",
   416  					Extension:  "xml",
   417  					Name:       "XML File",
   418  					Icon:       "https://example.org/icons&file=xml.png",
   419  					DefaultApp: "provider1",
   420  				},
   421  			},
   422  			regProviders: []*registrypb.ProviderInfo{
   423  				{
   424  					MimeTypes: []string{"text/json", "text/xml"},
   425  					Address:   "ip-provider1",
   426  					Name:      "provider1",
   427  					Opaque: &typesv1beta1.Opaque{
   428  						Map: map[string]*typesv1beta1.OpaqueEntry{
   429  							"priority": {
   430  								Decoder: "plain",
   431  								Value:   []byte("5"),
   432  							},
   433  						},
   434  					},
   435  				},
   436  				{
   437  					MimeTypes: []string{"text/json"},
   438  					Address:   "ip-provider2",
   439  					Name:      "provider2",
   440  					Opaque: &typesv1beta1.Opaque{
   441  						Map: map[string]*typesv1beta1.OpaqueEntry{
   442  							"priority": {
   443  								Decoder: "plain",
   444  								Value:   []byte("100"),
   445  							},
   446  						},
   447  					},
   448  				},
   449  				{
   450  					MimeTypes: []string{"text/xml"},
   451  					Address:   "ip-provider3",
   452  					Name:      "provider3",
   453  					Opaque: &typesv1beta1.Opaque{
   454  						Map: map[string]*typesv1beta1.OpaqueEntry{
   455  							"priority": {
   456  								Decoder: "plain",
   457  								Value:   []byte("20"),
   458  							},
   459  						},
   460  					},
   461  				},
   462  			},
   463  			mimeType:    "text/xml",
   464  			expectedErr: nil,
   465  			expectedRes: []*registrypb.ProviderInfo{
   466  				{
   467  					MimeTypes: []string{"text/xml"},
   468  					Address:   "ip-provider3",
   469  					Name:      "provider3",
   470  				},
   471  				{
   472  					MimeTypes: []string{"text/json", "text/xml"},
   473  					Address:   "ip-provider1",
   474  					Name:      "provider1",
   475  				},
   476  			},
   477  		},
   478  	}
   479  
   480  	for _, tt := range testCases {
   481  
   482  		t.Run(tt.name, func(t *testing.T) {
   483  
   484  			ctx := context.TODO()
   485  
   486  			registry, err := New(map[string]interface{}{
   487  				"mime_types": tt.mimeTypes,
   488  			})
   489  			if err != nil {
   490  				t.Error("unexpected error creating the registry:", err)
   491  			}
   492  
   493  			// register all the providers
   494  			for _, p := range tt.regProviders {
   495  				err := registry.AddProvider(ctx, p)
   496  				if err != nil {
   497  					t.Error("unexpected error adding a new provider in the registry:", err)
   498  				}
   499  			}
   500  
   501  			providers, err := registry.FindProviders(ctx, tt.mimeType)
   502  
   503  			// check that the error returned by FindProviders is the same as the expected
   504  			if tt.expectedErr != err {
   505  				t.Errorf("different error returned: got=%v expected=%v", err, tt.expectedErr)
   506  			}
   507  
   508  			if !providersEquals(providers, tt.expectedRes) {
   509  				t.Errorf("providers list different from expected: \n\tgot=%v\n\texp=%v", providers, tt.expectedRes)
   510  			}
   511  
   512  		})
   513  
   514  	}
   515  
   516  }
   517  
   518  func TestAddProvider(t *testing.T) {
   519  
   520  	testCases := []struct {
   521  		name              string
   522  		mimeTypes         []*mimeTypeConfig
   523  		initProviders     []*registrypb.ProviderInfo
   524  		newProvider       *registrypb.ProviderInfo
   525  		expectedProviders map[string][]*registrypb.ProviderInfo
   526  	}{
   527  		{
   528  			name:          "no mime types defined - no initial providers",
   529  			mimeTypes:     []*mimeTypeConfig{},
   530  			initProviders: []*registrypb.ProviderInfo{},
   531  			newProvider: &registrypb.ProviderInfo{
   532  				MimeTypes: []string{"text/json"},
   533  				Address:   "ip-provider1",
   534  				Name:      "provider1",
   535  			},
   536  			expectedProviders: map[string][]*registrypb.ProviderInfo{
   537  				"text/json": {
   538  					{
   539  						MimeTypes: []string{"text/json"},
   540  						Address:   "ip-provider1",
   541  						Name:      "provider1",
   542  					},
   543  				},
   544  			},
   545  		},
   546  		{
   547  			name: "one mime types defined - no initial providers - registering provider is the default",
   548  			mimeTypes: []*mimeTypeConfig{
   549  				{
   550  					MimeType:   "text/json",
   551  					Extension:  "json",
   552  					Name:       "JSON File",
   553  					Icon:       "https://example.org/icons&file=json.png",
   554  					DefaultApp: "provider1",
   555  				},
   556  			},
   557  			initProviders: []*registrypb.ProviderInfo{
   558  				{
   559  					MimeTypes: []string{"text/json"},
   560  					Address:   "ip-provider2",
   561  					Name:      "provider2",
   562  				},
   563  			},
   564  			newProvider: &registrypb.ProviderInfo{
   565  				MimeTypes: []string{"text/json"},
   566  				Address:   "ip-provider1",
   567  				Name:      "provider1",
   568  			},
   569  			expectedProviders: map[string][]*registrypb.ProviderInfo{
   570  				"text/json": {
   571  					{
   572  						MimeTypes: []string{"text/json"},
   573  						Address:   "ip-provider2",
   574  						Name:      "provider2",
   575  					},
   576  					{
   577  						MimeTypes: []string{"text/json"},
   578  						Address:   "ip-provider1",
   579  						Name:      "provider1",
   580  					},
   581  				},
   582  			},
   583  		},
   584  		{
   585  			name: "one mime types defined - no initial providers - default already registered",
   586  			mimeTypes: []*mimeTypeConfig{
   587  				{
   588  					MimeType:   "text/json",
   589  					Extension:  "json",
   590  					Name:       "JSON File",
   591  					Icon:       "https://example.org/icons&file=json.png",
   592  					DefaultApp: "provider2",
   593  				},
   594  			},
   595  			initProviders: []*registrypb.ProviderInfo{
   596  				{
   597  					MimeTypes: []string{"text/json"},
   598  					Address:   "ip-provider2",
   599  					Name:      "provider2",
   600  				},
   601  			},
   602  			newProvider: &registrypb.ProviderInfo{
   603  				MimeTypes: []string{"text/json"},
   604  				Address:   "ip-provider1",
   605  				Name:      "provider1",
   606  			},
   607  			expectedProviders: map[string][]*registrypb.ProviderInfo{
   608  				"text/json": {
   609  					{
   610  						MimeTypes: []string{"text/json"},
   611  						Address:   "ip-provider2",
   612  						Name:      "provider2",
   613  					},
   614  					{
   615  						MimeTypes: []string{"text/json"},
   616  						Address:   "ip-provider1",
   617  						Name:      "provider1",
   618  					},
   619  				},
   620  			},
   621  		},
   622  		{
   623  			name: "register a provider already registered",
   624  			mimeTypes: []*mimeTypeConfig{
   625  				{
   626  					MimeType:   "text/json",
   627  					Extension:  "json",
   628  					Name:       "JSON File",
   629  					Icon:       "https://example.org/icons&file=json.png",
   630  					DefaultApp: "provider2",
   631  				},
   632  			},
   633  			initProviders: []*registrypb.ProviderInfo{
   634  				{
   635  					MimeTypes: []string{"text/json"},
   636  					Address:   "ip-provider1",
   637  					Name:      "provider1",
   638  				},
   639  				{
   640  					MimeTypes: []string{"text/json"},
   641  					Address:   "ip-provider2",
   642  					Name:      "provider2",
   643  				},
   644  			},
   645  			newProvider: &registrypb.ProviderInfo{
   646  				MimeTypes: []string{"text/json"},
   647  				Address:   "ip-provider1",
   648  				Name:      "provider1",
   649  			},
   650  			expectedProviders: map[string][]*registrypb.ProviderInfo{
   651  				"text/json": {
   652  					{
   653  						MimeTypes: []string{"text/json"},
   654  						Address:   "ip-provider2",
   655  						Name:      "provider2",
   656  					},
   657  					{
   658  						MimeTypes: []string{"text/json"},
   659  						Address:   "ip-provider1",
   660  						Name:      "provider1",
   661  					},
   662  				},
   663  			},
   664  		},
   665  		{
   666  			name: "register a provider already registered supporting more mime types",
   667  			mimeTypes: []*mimeTypeConfig{
   668  				{
   669  					MimeType:   "text/json",
   670  					Extension:  "json",
   671  					Name:       "JSON File",
   672  					Icon:       "https://example.org/icons&file=json.png",
   673  					DefaultApp: "provider2",
   674  				},
   675  				{
   676  					MimeType:   "text/xml",
   677  					Extension:  "xml",
   678  					Name:       "XML File",
   679  					Icon:       "https://example.org/icons&file=xml.png",
   680  					DefaultApp: "provider1",
   681  				},
   682  			},
   683  			initProviders: []*registrypb.ProviderInfo{
   684  				{
   685  					MimeTypes: []string{"text/json"},
   686  					Address:   "ip-provider1",
   687  					Name:      "provider1",
   688  				},
   689  				{
   690  					MimeTypes: []string{"text/json"},
   691  					Address:   "ip-provider2",
   692  					Name:      "provider2",
   693  				},
   694  			},
   695  			newProvider: &registrypb.ProviderInfo{
   696  				MimeTypes: []string{"text/json", "text/xml"},
   697  				Address:   "ip-provider1",
   698  				Name:      "provider1",
   699  			},
   700  			expectedProviders: map[string][]*registrypb.ProviderInfo{
   701  				"text/json": {
   702  					{
   703  						MimeTypes: []string{"text/json"},
   704  						Address:   "ip-provider2",
   705  						Name:      "provider2",
   706  					},
   707  					{
   708  						MimeTypes: []string{"text/json", "text/xml"},
   709  						Address:   "ip-provider1",
   710  						Name:      "provider1",
   711  					},
   712  				},
   713  				"text/xml": {
   714  					{
   715  						MimeTypes: []string{"text/json", "text/xml"},
   716  						Address:   "ip-provider1",
   717  						Name:      "provider1",
   718  					},
   719  				},
   720  			},
   721  		},
   722  		{
   723  			name: "register a provider already registered supporting less mime types",
   724  			mimeTypes: []*mimeTypeConfig{
   725  				{
   726  					MimeType:   "text/json",
   727  					Extension:  "json",
   728  					Name:       "JSON File",
   729  					Icon:       "https://example.org/icons&file=json.png",
   730  					DefaultApp: "provider2",
   731  				},
   732  				{
   733  					MimeType:   "text/xml",
   734  					Extension:  "xml",
   735  					Name:       "XML File",
   736  					Icon:       "https://example.org/icons&file=xml.png",
   737  					DefaultApp: "provider1",
   738  				},
   739  			},
   740  			initProviders: []*registrypb.ProviderInfo{
   741  				{
   742  					MimeTypes: []string{"text/json", "text/xml"},
   743  					Address:   "ip-provider1",
   744  					Name:      "provider1",
   745  				},
   746  				{
   747  					MimeTypes: []string{"text/json"},
   748  					Address:   "ip-provider2",
   749  					Name:      "provider2",
   750  				},
   751  			},
   752  			newProvider: &registrypb.ProviderInfo{
   753  				MimeTypes: []string{"text/json"},
   754  				Address:   "ip-provider1",
   755  				Name:      "provider1",
   756  			},
   757  			expectedProviders: map[string][]*registrypb.ProviderInfo{
   758  				"text/json": {
   759  					{
   760  						MimeTypes: []string{"text/json"},
   761  						Address:   "ip-provider2",
   762  						Name:      "provider2",
   763  					},
   764  					{
   765  						MimeTypes: []string{"text/json"},
   766  						Address:   "ip-provider1",
   767  						Name:      "provider1",
   768  					},
   769  				},
   770  				"text/xml": {},
   771  			},
   772  		},
   773  	}
   774  
   775  	for _, tt := range testCases {
   776  		t.Run(tt.name, func(t *testing.T) {
   777  
   778  			ctx := context.TODO()
   779  
   780  			registry, err := New(map[string]interface{}{
   781  				"providers":  tt.initProviders,
   782  				"mime_types": tt.mimeTypes,
   783  			})
   784  			if err != nil {
   785  				t.Error("unexpected error creating the registry:", err)
   786  			}
   787  
   788  			err = registry.AddProvider(ctx, tt.newProvider)
   789  			if err != nil {
   790  				t.Error("unexpected error adding a new provider:", err)
   791  			}
   792  
   793  			// test that the internal set of providers keep the new provider
   794  			// and the key is the provider's address
   795  			staticReg := registry.(*manager)
   796  
   797  			in, ok := staticReg.providers[tt.newProvider.Address]
   798  			if !ok {
   799  				t.Error("cannot find a provider in the internal map with address", tt.newProvider.Address)
   800  			}
   801  
   802  			// check that the provider in the set is the same as the new one
   803  			if !equalsProviderInfo(tt.newProvider, in) {
   804  				t.Errorf("providers are different: got=%v expected=%v", in, tt.newProvider)
   805  			}
   806  
   807  			for mime, expAddrs := range tt.expectedProviders {
   808  				mimeConfInterface, _ := staticReg.mimetypes.Get(mime)
   809  				addrsReg := mimeConfInterface.(*mimeTypeConfig).apps.getOrderedProviderByPriority()
   810  
   811  				if !reflect.DeepEqual(expAddrs, addrsReg) {
   812  					t.Errorf("list of addresses different from expected: \n\tgot=%v\n\texp=%v", addrsReg, expAddrs)
   813  				}
   814  			}
   815  
   816  		})
   817  	}
   818  
   819  }
   820  
   821  func TestListSupportedMimeTypes(t *testing.T) {
   822  	testCases := []struct {
   823  		name         string
   824  		mimeTypes    []*mimeTypeConfig
   825  		newProviders []*registrypb.ProviderInfo
   826  		expected     []*registrypb.MimeTypeInfo
   827  	}{
   828  		{
   829  			name: "one mime type - no provider registered",
   830  			mimeTypes: []*mimeTypeConfig{
   831  				{
   832  					MimeType:   "text/json",
   833  					Extension:  "json",
   834  					Name:       "JSON File",
   835  					Icon:       "https://example.org/icons&file=json.png",
   836  					DefaultApp: "provider2",
   837  				},
   838  			},
   839  			newProviders: []*registrypb.ProviderInfo{},
   840  			expected: []*registrypb.MimeTypeInfo{
   841  				{
   842  					MimeType:           "text/json",
   843  					Ext:                "json",
   844  					AppProviders:       []*registrypb.ProviderInfo{},
   845  					Name:               "JSON File",
   846  					Icon:               "https://example.org/icons&file=json.png",
   847  					DefaultApplication: "provider2",
   848  				},
   849  			},
   850  		},
   851  		{
   852  			name: "one mime type - only default provider registered",
   853  			mimeTypes: []*mimeTypeConfig{
   854  				{
   855  					MimeType:   "text/json",
   856  					Extension:  "json",
   857  					Name:       "JSON File",
   858  					Icon:       "https://example.org/icons&file=json.png",
   859  					DefaultApp: "provider1",
   860  				},
   861  			},
   862  			newProviders: []*registrypb.ProviderInfo{
   863  				{
   864  					MimeTypes: []string{"text/json"},
   865  					Address:   "ip-provider1",
   866  					Name:      "provider1",
   867  				},
   868  			},
   869  			expected: []*registrypb.MimeTypeInfo{
   870  				{
   871  					MimeType: "text/json",
   872  					Ext:      "json",
   873  					AppProviders: []*registrypb.ProviderInfo{
   874  						{
   875  							MimeTypes: []string{"text/json"},
   876  							Address:   "ip-provider1",
   877  							Name:      "provider1",
   878  						},
   879  					},
   880  					DefaultApplication: "provider1",
   881  					Name:               "JSON File",
   882  					Icon:               "https://example.org/icons&file=json.png",
   883  				},
   884  			},
   885  		},
   886  		{
   887  			name: "one mime type - more providers",
   888  			mimeTypes: []*mimeTypeConfig{
   889  				{
   890  					MimeType:   "text/json",
   891  					Extension:  "json",
   892  					Name:       "JSON File",
   893  					Icon:       "https://example.org/icons&file=json.png",
   894  					DefaultApp: "JSON_DEFAULT_PROVIDER",
   895  				},
   896  			},
   897  			newProviders: []*registrypb.ProviderInfo{
   898  				{
   899  					MimeTypes: []string{"text/json"},
   900  					Address:   "ip-provider2",
   901  					Name:      "NOT_DEFAULT_PROVIDER",
   902  				},
   903  				{
   904  					MimeTypes: []string{"text/json"},
   905  					Address:   "ip-provider1",
   906  					Name:      "JSON_DEFAULT_PROVIDER",
   907  				},
   908  			},
   909  			expected: []*registrypb.MimeTypeInfo{
   910  				{
   911  					MimeType: "text/json",
   912  					Ext:      "json",
   913  					AppProviders: []*registrypb.ProviderInfo{
   914  						{
   915  							MimeTypes: []string{"text/json"},
   916  							Address:   "ip-provider2",
   917  							Name:      "NOT_DEFAULT_PROVIDER",
   918  						},
   919  						{
   920  							MimeTypes: []string{"text/json"},
   921  							Address:   "ip-provider1",
   922  							Name:      "JSON_DEFAULT_PROVIDER",
   923  						},
   924  					},
   925  					DefaultApplication: "JSON_DEFAULT_PROVIDER",
   926  					Name:               "JSON File",
   927  					Icon:               "https://example.org/icons&file=json.png",
   928  				},
   929  			},
   930  		},
   931  		{
   932  			name: "multiple mime types",
   933  			mimeTypes: []*mimeTypeConfig{
   934  				{
   935  					MimeType:   "text/json",
   936  					Extension:  "json",
   937  					Name:       "JSON File",
   938  					Icon:       "https://example.org/icons&file=json.png",
   939  					DefaultApp: "JSON_DEFAULT_PROVIDER",
   940  				},
   941  				{
   942  					MimeType:   "text/xml",
   943  					Extension:  "xml",
   944  					Name:       "XML File",
   945  					Icon:       "https://example.org/icons&file=xml.png",
   946  					DefaultApp: "XML_DEFAULT_PROVIDER",
   947  				},
   948  			},
   949  			newProviders: []*registrypb.ProviderInfo{
   950  				{
   951  					MimeTypes: []string{"text/json", "text/xml"},
   952  					Address:   "1",
   953  					Name:      "NOT_DEFAULT_PROVIDER2",
   954  				},
   955  				{
   956  					MimeTypes: []string{"text/xml"},
   957  					Address:   "2",
   958  					Name:      "NOT_DEFAULT_PROVIDER1",
   959  				},
   960  				{
   961  					MimeTypes: []string{"text/xml", "text/json"},
   962  					Address:   "3",
   963  					Name:      "JSON_DEFAULT_PROVIDER",
   964  				},
   965  				{
   966  					MimeTypes: []string{"text/xml", "text/json"},
   967  					Address:   "4",
   968  					Name:      "XML_DEFAULT_PROVIDER",
   969  				},
   970  			},
   971  			expected: []*registrypb.MimeTypeInfo{
   972  				{
   973  					MimeType: "text/json",
   974  					Ext:      "json",
   975  					AppProviders: []*registrypb.ProviderInfo{
   976  						{
   977  							MimeTypes: []string{"text/json", "text/xml"},
   978  							Address:   "1",
   979  							Name:      "NOT_DEFAULT_PROVIDER2",
   980  						},
   981  						{
   982  							MimeTypes: []string{"text/xml", "text/json"},
   983  							Address:   "3",
   984  							Name:      "JSON_DEFAULT_PROVIDER",
   985  						},
   986  						{
   987  							MimeTypes: []string{"text/xml", "text/json"},
   988  							Address:   "4",
   989  							Name:      "XML_DEFAULT_PROVIDER",
   990  						},
   991  					},
   992  					DefaultApplication: "JSON_DEFAULT_PROVIDER",
   993  					Name:               "JSON File",
   994  					Icon:               "https://example.org/icons&file=json.png",
   995  				},
   996  				{
   997  					MimeType: "text/xml",
   998  					Ext:      "xml",
   999  					AppProviders: []*registrypb.ProviderInfo{
  1000  						{
  1001  							MimeTypes: []string{"text/json", "text/xml"},
  1002  							Address:   "1",
  1003  							Name:      "NOT_DEFAULT_PROVIDER2",
  1004  						},
  1005  						{
  1006  							MimeTypes: []string{"text/xml"},
  1007  							Address:   "2",
  1008  							Name:      "NOT_DEFAULT_PROVIDER1",
  1009  						},
  1010  						{
  1011  							MimeTypes: []string{"text/xml", "text/json"},
  1012  							Address:   "3",
  1013  							Name:      "JSON_DEFAULT_PROVIDER",
  1014  						},
  1015  						{
  1016  							MimeTypes: []string{"text/xml", "text/json"},
  1017  							Address:   "4",
  1018  							Name:      "XML_DEFAULT_PROVIDER",
  1019  						},
  1020  					},
  1021  					DefaultApplication: "XML_DEFAULT_PROVIDER",
  1022  					Name:               "XML File",
  1023  					Icon:               "https://example.org/icons&file=xml.png",
  1024  				},
  1025  			},
  1026  		},
  1027  	}
  1028  
  1029  	for _, tt := range testCases {
  1030  		t.Run(tt.name, func(t *testing.T) {
  1031  
  1032  			ctx := context.TODO()
  1033  
  1034  			registry, err := New(map[string]interface{}{
  1035  				"mime_types": tt.mimeTypes,
  1036  			})
  1037  			if err != nil {
  1038  				t.Error("unexpected error creating the registry:", err)
  1039  			}
  1040  
  1041  			// add all the providers
  1042  			for _, p := range tt.newProviders {
  1043  				err = registry.AddProvider(ctx, p)
  1044  				if err != nil {
  1045  					t.Error("unexpected error creating adding new providers:", err)
  1046  				}
  1047  			}
  1048  
  1049  			got, err := registry.ListSupportedMimeTypes(ctx)
  1050  			if err != nil {
  1051  				t.Error("unexpected error listing supported mime types:", err)
  1052  			}
  1053  
  1054  			if !mimeTypesEquals(got, tt.expected) {
  1055  				t.Errorf("mime types list different from expected: \n\tgot=%v\n\texp=%v", got, tt.expected)
  1056  			}
  1057  
  1058  		})
  1059  	}
  1060  }
  1061  
  1062  func TestSetDefaultProviderForMimeType(t *testing.T) {
  1063  	testCases := []struct {
  1064  		name          string
  1065  		mimeTypes     []*mimeTypeConfig
  1066  		initProviders []*registrypb.ProviderInfo
  1067  		newDefault    struct {
  1068  			mimeType string
  1069  			provider *registrypb.ProviderInfo
  1070  		}
  1071  		newProviders []*registrypb.ProviderInfo
  1072  	}{
  1073  		{
  1074  			name: "set new default - no new providers",
  1075  			mimeTypes: []*mimeTypeConfig{
  1076  				{
  1077  					MimeType:   "text/json",
  1078  					Extension:  "json",
  1079  					Name:       "JSON File",
  1080  					Icon:       "https://example.org/icons&file=json.png",
  1081  					DefaultApp: "JSON_DEFAULT_PROVIDER",
  1082  				},
  1083  			},
  1084  			initProviders: []*registrypb.ProviderInfo{
  1085  				{
  1086  					MimeTypes: []string{"text/json"},
  1087  					Address:   "1",
  1088  					Name:      "JSON_DEFAULT_PROVIDER",
  1089  				},
  1090  				{
  1091  					MimeTypes: []string{"text/json"},
  1092  					Address:   "2",
  1093  					Name:      "NEW_DEFAULT",
  1094  				},
  1095  			},
  1096  			newDefault: struct {
  1097  				mimeType string
  1098  				provider *registrypb.ProviderInfo
  1099  			}{
  1100  				mimeType: "text/json",
  1101  				provider: &registrypb.ProviderInfo{
  1102  					MimeTypes: []string{"text/json"},
  1103  					Address:   "2",
  1104  					Name:      "NEW_DEFAULT",
  1105  				},
  1106  			},
  1107  			newProviders: []*registrypb.ProviderInfo{},
  1108  		},
  1109  		{
  1110  			name: "set default - other providers (one is the previous default)",
  1111  			mimeTypes: []*mimeTypeConfig{
  1112  				{
  1113  					MimeType:   "text/json",
  1114  					Extension:  "json",
  1115  					Name:       "JSON File",
  1116  					Icon:       "https://example.org/icons&file=json.png",
  1117  					DefaultApp: "JSON_DEFAULT_PROVIDER",
  1118  				},
  1119  			},
  1120  			initProviders: []*registrypb.ProviderInfo{
  1121  				{
  1122  					MimeTypes: []string{"text/json"},
  1123  					Address:   "4",
  1124  					Name:      "NO_DEFAULT_PROVIDER",
  1125  				},
  1126  				{
  1127  					MimeTypes: []string{"text/json"},
  1128  					Address:   "2",
  1129  					Name:      "NEW_DEFAULT",
  1130  				},
  1131  			},
  1132  			newDefault: struct {
  1133  				mimeType string
  1134  				provider *registrypb.ProviderInfo
  1135  			}{
  1136  				mimeType: "text/json",
  1137  				provider: &registrypb.ProviderInfo{
  1138  					MimeTypes: []string{"text/json"},
  1139  					Address:   "2",
  1140  					Name:      "NEW_DEFAULT",
  1141  				},
  1142  			},
  1143  			newProviders: []*registrypb.ProviderInfo{
  1144  				{
  1145  					MimeTypes: []string{"text/json"},
  1146  					Address:   "1",
  1147  					Name:      "JSON_DEFAULT_PROVIDER",
  1148  				},
  1149  				{
  1150  					MimeTypes: []string{"text/json"},
  1151  					Address:   "3",
  1152  					Name:      "OTHER_PROVIDER",
  1153  				},
  1154  			},
  1155  		},
  1156  	}
  1157  
  1158  	for _, tt := range testCases {
  1159  		t.Run(tt.name, func(t *testing.T) {
  1160  
  1161  			ctx := context.TODO()
  1162  
  1163  			registry, err := New(map[string]interface{}{
  1164  				"providers":  tt.initProviders,
  1165  				"mime_types": tt.mimeTypes,
  1166  			})
  1167  			if err != nil {
  1168  				t.Error("unexpected error creating a new registry:", err)
  1169  			}
  1170  
  1171  			err = registry.SetDefaultProviderForMimeType(ctx, tt.newDefault.mimeType, tt.newDefault.provider)
  1172  			if err != nil {
  1173  				t.Error("unexpected error setting a default provider for mime type:", err)
  1174  			}
  1175  
  1176  			// add other provider to move things around internally :)
  1177  			for _, p := range tt.newProviders {
  1178  				err = registry.AddProvider(ctx, p)
  1179  				if err != nil {
  1180  					t.Error("unexpected error adding a new provider:", err)
  1181  				}
  1182  			}
  1183  
  1184  			// check if the new default is the one set
  1185  			got, err := registry.GetDefaultProviderForMimeType(ctx, tt.newDefault.mimeType)
  1186  			if err != nil {
  1187  				t.Error("unexpected error getting the default app provider:", err)
  1188  			}
  1189  
  1190  			if !equalsProviderInfo(got, tt.newDefault.provider) {
  1191  				t.Errorf("provider differ from expected:\n\tgot=%v\n\texp=%v", got, tt.newDefault.provider)
  1192  			}
  1193  
  1194  		})
  1195  	}
  1196  }
  1197  
  1198  func mimeTypesEquals(l1, l2 []*registrypb.MimeTypeInfo) bool {
  1199  	if len(l1) != len(l2) {
  1200  		return false
  1201  	}
  1202  
  1203  	for i := 0; i < len(l1); i++ {
  1204  		if !equalsMimeTypeInfo(l1[i], l2[i]) {
  1205  			return false
  1206  		}
  1207  	}
  1208  	return true
  1209  }
  1210  
  1211  func equalsMimeTypeInfo(m1, m2 *registrypb.MimeTypeInfo) bool {
  1212  	return m1.Description == m2.Description &&
  1213  		m1.AllowCreation == m2.AllowCreation &&
  1214  		providersEquals(m1.AppProviders, m2.AppProviders) &&
  1215  		m1.Ext == m2.Ext &&
  1216  		m1.MimeType == m2.MimeType &&
  1217  		m1.Name == m2.Name &&
  1218  		m1.DefaultApplication == m2.DefaultApplication
  1219  }