storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/pkg/bucket/policy/condition/binaryequalsfunc_test.go (about)

     1  /*
     2   * MinIO Cloud Storage, (C) 2018 MinIO, Inc.
     3   *
     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   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package condition
    18  
    19  import (
    20  	"encoding/base64"
    21  	"reflect"
    22  	"testing"
    23  )
    24  
    25  func TestBinaryEqualsFuncEvaluate(t *testing.T) {
    26  	case1Function, err := newBinaryEqualsFunc(S3XAmzCopySource,
    27  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject")))))
    28  	if err != nil {
    29  		t.Fatalf("unexpected error. %v\n", err)
    30  	}
    31  
    32  	case2Function, err := newBinaryEqualsFunc(S3XAmzServerSideEncryption,
    33  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256")))))
    34  	if err != nil {
    35  		t.Fatalf("unexpected error. %v\n", err)
    36  	}
    37  
    38  	case3Function, err := newBinaryEqualsFunc(S3XAmzMetadataDirective,
    39  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE")))))
    40  	if err != nil {
    41  		t.Fatalf("unexpected error. %v\n", err)
    42  	}
    43  
    44  	case4Function, err := newBinaryEqualsFunc(S3LocationConstraint,
    45  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1")))))
    46  	if err != nil {
    47  		t.Fatalf("unexpected error. %v\n", err)
    48  	}
    49  
    50  	testCases := []struct {
    51  		function       Function
    52  		values         map[string][]string
    53  		expectedResult bool
    54  	}{
    55  		{case1Function, map[string][]string{"x-amz-copy-source": {"mybucket/myobject"}}, true},
    56  		{case1Function, map[string][]string{"x-amz-copy-source": {"yourbucket/myobject"}}, false},
    57  		{case1Function, map[string][]string{}, false},
    58  		{case1Function, map[string][]string{"delimiter": {"/"}}, false},
    59  
    60  		{case2Function, map[string][]string{"x-amz-server-side-encryption": {"AES256"}}, true},
    61  		{case2Function, map[string][]string{}, false},
    62  		{case2Function, map[string][]string{"delimiter": {"/"}}, false},
    63  
    64  		{case3Function, map[string][]string{"x-amz-metadata-directive": {"REPLACE"}}, true},
    65  		{case3Function, map[string][]string{"x-amz-metadata-directive": {"COPY"}}, false},
    66  		{case3Function, map[string][]string{}, false},
    67  		{case3Function, map[string][]string{"delimiter": {"/"}}, false},
    68  
    69  		{case4Function, map[string][]string{"LocationConstraint": {"eu-west-1"}}, true},
    70  		{case4Function, map[string][]string{"LocationConstraint": {"us-east-1"}}, false},
    71  		{case4Function, map[string][]string{}, false},
    72  		{case4Function, map[string][]string{"delimiter": {"/"}}, false},
    73  	}
    74  
    75  	for i, testCase := range testCases {
    76  		result := testCase.function.evaluate(testCase.values)
    77  
    78  		if result != testCase.expectedResult {
    79  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
    80  		}
    81  	}
    82  }
    83  
    84  func TestBinaryEqualsFuncKey(t *testing.T) {
    85  	case1Function, err := newBinaryEqualsFunc(S3XAmzCopySource,
    86  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject")))))
    87  	if err != nil {
    88  		t.Fatalf("unexpected error. %v\n", err)
    89  	}
    90  
    91  	case2Function, err := newBinaryEqualsFunc(S3XAmzServerSideEncryption,
    92  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256")))))
    93  	if err != nil {
    94  		t.Fatalf("unexpected error. %v\n", err)
    95  	}
    96  
    97  	case3Function, err := newBinaryEqualsFunc(S3XAmzMetadataDirective,
    98  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE")))))
    99  	if err != nil {
   100  		t.Fatalf("unexpected error. %v\n", err)
   101  	}
   102  
   103  	case4Function, err := newBinaryEqualsFunc(S3LocationConstraint,
   104  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1")))))
   105  	if err != nil {
   106  		t.Fatalf("unexpected error. %v\n", err)
   107  	}
   108  
   109  	testCases := []struct {
   110  		function       Function
   111  		expectedResult Key
   112  	}{
   113  		{case1Function, S3XAmzCopySource},
   114  		{case2Function, S3XAmzServerSideEncryption},
   115  		{case3Function, S3XAmzMetadataDirective},
   116  		{case4Function, S3LocationConstraint},
   117  	}
   118  
   119  	for i, testCase := range testCases {
   120  		result := testCase.function.key()
   121  
   122  		if result != testCase.expectedResult {
   123  			t.Fatalf("case %v: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   124  		}
   125  	}
   126  }
   127  
   128  func TestBinaryEqualsFuncToMap(t *testing.T) {
   129  	case1Function, err := newBinaryEqualsFunc(S3XAmzCopySource,
   130  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject")))))
   131  	if err != nil {
   132  		t.Fatalf("unexpected error. %v\n", err)
   133  	}
   134  
   135  	case1Result := map[Key]ValueSet{
   136  		S3XAmzCopySource: NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject")))),
   137  	}
   138  
   139  	case2Function, err := newBinaryEqualsFunc(S3XAmzCopySource,
   140  		NewValueSet(
   141  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject"))),
   142  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("yourbucket/myobject"))),
   143  		),
   144  	)
   145  	if err != nil {
   146  		t.Fatalf("unexpected error. %v\n", err)
   147  	}
   148  
   149  	case2Result := map[Key]ValueSet{
   150  		S3XAmzCopySource: NewValueSet(
   151  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject"))),
   152  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("yourbucket/myobject"))),
   153  		),
   154  	}
   155  
   156  	case3Function, err := newBinaryEqualsFunc(S3XAmzServerSideEncryption,
   157  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256")))))
   158  	if err != nil {
   159  		t.Fatalf("unexpected error. %v\n", err)
   160  	}
   161  
   162  	case3Result := map[Key]ValueSet{
   163  		S3XAmzServerSideEncryption: NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256")))),
   164  	}
   165  
   166  	case4Function, err := newBinaryEqualsFunc(S3XAmzServerSideEncryption,
   167  		NewValueSet(
   168  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256"))),
   169  		),
   170  	)
   171  	if err != nil {
   172  		t.Fatalf("unexpected error. %v\n", err)
   173  	}
   174  
   175  	case4Result := map[Key]ValueSet{
   176  		S3XAmzServerSideEncryption: NewValueSet(
   177  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256"))),
   178  		),
   179  	}
   180  
   181  	case5Function, err := newBinaryEqualsFunc(S3XAmzMetadataDirective,
   182  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE")))))
   183  	if err != nil {
   184  		t.Fatalf("unexpected error. %v\n", err)
   185  	}
   186  
   187  	case5Result := map[Key]ValueSet{
   188  		S3XAmzMetadataDirective: NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE")))),
   189  	}
   190  
   191  	case6Function, err := newBinaryEqualsFunc(S3XAmzMetadataDirective,
   192  		NewValueSet(
   193  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE"))),
   194  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("COPY"))),
   195  		),
   196  	)
   197  	if err != nil {
   198  		t.Fatalf("unexpected error. %v\n", err)
   199  	}
   200  
   201  	case6Result := map[Key]ValueSet{
   202  		S3XAmzMetadataDirective: NewValueSet(
   203  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE"))),
   204  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("COPY"))),
   205  		),
   206  	}
   207  
   208  	case7Function, err := newBinaryEqualsFunc(S3LocationConstraint,
   209  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1")))))
   210  	if err != nil {
   211  		t.Fatalf("unexpected error. %v\n", err)
   212  	}
   213  
   214  	case7Result := map[Key]ValueSet{
   215  		S3LocationConstraint: NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1")))),
   216  	}
   217  
   218  	case8Function, err := newBinaryEqualsFunc(S3LocationConstraint,
   219  		NewValueSet(
   220  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1"))),
   221  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("us-west-1"))),
   222  		),
   223  	)
   224  	if err != nil {
   225  		t.Fatalf("unexpected error. %v\n", err)
   226  	}
   227  
   228  	case8Result := map[Key]ValueSet{
   229  		S3LocationConstraint: NewValueSet(
   230  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1"))),
   231  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("us-west-1"))),
   232  		),
   233  	}
   234  
   235  	testCases := []struct {
   236  		f              Function
   237  		expectedResult map[Key]ValueSet
   238  	}{
   239  		{case1Function, case1Result},
   240  		{case2Function, case2Result},
   241  		{case3Function, case3Result},
   242  		{case4Function, case4Result},
   243  		{case5Function, case5Result},
   244  		{case6Function, case6Result},
   245  		{case7Function, case7Result},
   246  		{case8Function, case8Result},
   247  		{&binaryEqualsFunc{}, nil},
   248  	}
   249  
   250  	for i, testCase := range testCases {
   251  		result := testCase.f.toMap()
   252  
   253  		if !reflect.DeepEqual(result, testCase.expectedResult) {
   254  			t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   255  		}
   256  	}
   257  }
   258  
   259  func TestNewBinaryEqualsFunc(t *testing.T) {
   260  	case1Function, err := newBinaryEqualsFunc(S3XAmzCopySource,
   261  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject")))))
   262  	if err != nil {
   263  		t.Fatalf("unexpected error. %v\n", err)
   264  	}
   265  
   266  	case2Function, err := newBinaryEqualsFunc(S3XAmzCopySource,
   267  		NewValueSet(
   268  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject"))),
   269  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("yourbucket/myobject"))),
   270  		),
   271  	)
   272  	if err != nil {
   273  		t.Fatalf("unexpected error. %v\n", err)
   274  	}
   275  
   276  	case3Function, err := newBinaryEqualsFunc(S3XAmzServerSideEncryption,
   277  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256")))))
   278  	if err != nil {
   279  		t.Fatalf("unexpected error. %v\n", err)
   280  	}
   281  
   282  	case4Function, err := newBinaryEqualsFunc(S3XAmzServerSideEncryption,
   283  		NewValueSet(
   284  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256"))),
   285  		),
   286  	)
   287  	if err != nil {
   288  		t.Fatalf("unexpected error. %v\n", err)
   289  	}
   290  
   291  	case5Function, err := newBinaryEqualsFunc(S3XAmzMetadataDirective,
   292  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE")))))
   293  	if err != nil {
   294  		t.Fatalf("unexpected error. %v\n", err)
   295  	}
   296  
   297  	case6Function, err := newBinaryEqualsFunc(S3XAmzMetadataDirective,
   298  		NewValueSet(
   299  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE"))),
   300  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("COPY"))),
   301  		),
   302  	)
   303  	if err != nil {
   304  		t.Fatalf("unexpected error. %v\n", err)
   305  	}
   306  
   307  	case7Function, err := newBinaryEqualsFunc(S3LocationConstraint,
   308  		NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1")))))
   309  	if err != nil {
   310  		t.Fatalf("unexpected error. %v\n", err)
   311  	}
   312  
   313  	case8Function, err := newBinaryEqualsFunc(S3LocationConstraint,
   314  		NewValueSet(
   315  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1"))),
   316  			NewStringValue(base64.StdEncoding.EncodeToString([]byte("us-west-1"))),
   317  		),
   318  	)
   319  	if err != nil {
   320  		t.Fatalf("unexpected error. %v\n", err)
   321  	}
   322  
   323  	testCases := []struct {
   324  		key            Key
   325  		values         ValueSet
   326  		expectedResult Function
   327  		expectErr      bool
   328  	}{
   329  		{S3XAmzCopySource, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject")))), case1Function, false},
   330  		{S3XAmzCopySource,
   331  			NewValueSet(
   332  				NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject"))),
   333  				NewStringValue(base64.StdEncoding.EncodeToString([]byte("yourbucket/myobject"))),
   334  			), case2Function, false},
   335  
   336  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256")))), case3Function, false},
   337  		{S3XAmzServerSideEncryption,
   338  			NewValueSet(
   339  				NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256"))),
   340  			), case4Function, false},
   341  
   342  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE")))), case5Function, false},
   343  		{S3XAmzMetadataDirective,
   344  			NewValueSet(
   345  				NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE"))),
   346  				NewStringValue(base64.StdEncoding.EncodeToString([]byte("COPY"))),
   347  			), case6Function, false},
   348  
   349  		{S3LocationConstraint, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1")))), case7Function, false},
   350  		{S3LocationConstraint,
   351  			NewValueSet(
   352  				NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1"))),
   353  				NewStringValue(base64.StdEncoding.EncodeToString([]byte("us-west-1"))),
   354  			), case8Function, false},
   355  
   356  		// Unsupported value error.
   357  		{S3XAmzCopySource, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket/myobject"))), NewIntValue(7)), nil, true},
   358  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("AES256"))), NewIntValue(7)), nil, true},
   359  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("REPLACE"))), NewIntValue(7)), nil, true},
   360  		{S3LocationConstraint, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("eu-west-1"))), NewIntValue(7)), nil, true},
   361  
   362  		// Invalid value error.
   363  		{S3XAmzCopySource, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("mybucket")))), nil, true},
   364  		{S3XAmzServerSideEncryption, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("SSE-C")))), nil, true},
   365  		{S3XAmzMetadataDirective, NewValueSet(NewStringValue(base64.StdEncoding.EncodeToString([]byte("DUPLICATE")))), nil, true},
   366  	}
   367  
   368  	for i, testCase := range testCases {
   369  		result, err := newBinaryEqualsFunc(testCase.key, testCase.values)
   370  		expectErr := (err != nil)
   371  
   372  		if expectErr != testCase.expectErr {
   373  			t.Fatalf("case %v: error: expected: %v, got: %v\n", i+1, testCase.expectErr, expectErr)
   374  		}
   375  
   376  		if !testCase.expectErr {
   377  			if !reflect.DeepEqual(result, testCase.expectedResult) {
   378  				t.Fatalf("case %v: result: expected: %v, got: %v\n", i+1, testCase.expectedResult, result)
   379  			}
   380  		}
   381  	}
   382  }