github.com/google/osv-scalibr@v0.4.1/extractor/filesystem/runtime/asdf/metadata/metadata_test.go (about)

     1  // Copyright 2025 Google LLC
     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  package metadata_test
    16  
    17  import (
    18  	"testing"
    19  
    20  	"github.com/google/go-cmp/cmp"
    21  	"github.com/google/osv-scalibr/extractor/filesystem/runtime/asdf/metadata"
    22  	"google.golang.org/protobuf/proto"
    23  	"google.golang.org/protobuf/testing/protocmp"
    24  
    25  	pb "github.com/google/osv-scalibr/binary/proto/scan_result_go_proto"
    26  )
    27  
    28  func TestSetProto(t *testing.T) {
    29  	testCases := []struct {
    30  		desc string
    31  		m    *metadata.Metadata
    32  		p    *pb.Package
    33  		want *pb.Package
    34  	}{
    35  		{
    36  			desc: "nil_metadata",
    37  			m:    nil,
    38  			p:    &pb.Package{Name: "some-package"},
    39  			want: &pb.Package{Name: "some-package"},
    40  		},
    41  		{
    42  			desc: "nil_package",
    43  			m: &metadata.Metadata{
    44  				ToolName: "name",
    45  			},
    46  			p:    nil,
    47  			want: nil,
    48  		},
    49  		{
    50  			desc: "set_metadata",
    51  			m: &metadata.Metadata{
    52  				ToolName: "name",
    53  			},
    54  			p: &pb.Package{Name: "some-package"},
    55  			want: &pb.Package{
    56  				Name: "some-package",
    57  				Metadata: &pb.Package_AsdfMetadata{
    58  					AsdfMetadata: &pb.AsdfMetadata{
    59  						ToolName: "name",
    60  					},
    61  				},
    62  			},
    63  		},
    64  		{
    65  			desc: "override_metadata",
    66  			m: &metadata.Metadata{
    67  				ToolName: "another-name",
    68  			},
    69  			p: &pb.Package{
    70  				Name: "some-package",
    71  				Metadata: &pb.Package_AsdfMetadata{
    72  					AsdfMetadata: &pb.AsdfMetadata{
    73  						ToolName: "name",
    74  					},
    75  				},
    76  			},
    77  			want: &pb.Package{
    78  				Name: "some-package",
    79  				Metadata: &pb.Package_AsdfMetadata{
    80  					AsdfMetadata: &pb.AsdfMetadata{
    81  						ToolName: "another-name",
    82  					},
    83  				},
    84  			},
    85  		},
    86  		{
    87  			desc: "set_all_fields",
    88  			m: &metadata.Metadata{
    89  				ToolName:    "name",
    90  				ToolVersion: "version",
    91  			},
    92  			p: &pb.Package{Name: "some-package"},
    93  			want: &pb.Package{
    94  				Name: "some-package",
    95  				Metadata: &pb.Package_AsdfMetadata{
    96  					AsdfMetadata: &pb.AsdfMetadata{
    97  						ToolName:    "name",
    98  						ToolVersion: "version",
    99  					},
   100  				},
   101  			},
   102  		},
   103  	}
   104  
   105  	for _, tc := range testCases {
   106  		t.Run(tc.desc, func(t *testing.T) {
   107  			p := proto.Clone(tc.p).(*pb.Package)
   108  			tc.m.SetProto(p)
   109  			opts := []cmp.Option{
   110  				protocmp.Transform(),
   111  			}
   112  			if diff := cmp.Diff(tc.want, p, opts...); diff != "" {
   113  				t.Errorf("Metatadata{%+v}.SetProto(%+v): (-want +got):\n%s", tc.m, tc.p, diff)
   114  			}
   115  
   116  			// Test the reverse conversion for completeness.
   117  
   118  			if tc.p == nil && tc.want == nil {
   119  				return
   120  			}
   121  
   122  			got := metadata.ToStruct(p.GetAsdfMetadata())
   123  			if diff := cmp.Diff(tc.m, got); diff != "" {
   124  				t.Errorf("ToStruct(%+v): (-want +got):\n%s", p.GetAsdfMetadata(), diff)
   125  			}
   126  		})
   127  	}
   128  }
   129  
   130  func TestToStruct(t *testing.T) {
   131  	testCases := []struct {
   132  		desc string
   133  		m    *pb.AsdfMetadata
   134  		want *metadata.Metadata
   135  	}{
   136  		{
   137  			desc: "nil",
   138  			m:    nil,
   139  			want: nil,
   140  		},
   141  		{
   142  			desc: "some_fields",
   143  			m: &pb.AsdfMetadata{
   144  				ToolName: "name",
   145  			},
   146  			want: &metadata.Metadata{
   147  				ToolName: "name",
   148  			},
   149  		},
   150  		{
   151  			desc: "all_fields",
   152  			m: &pb.AsdfMetadata{
   153  				ToolName:    "name",
   154  				ToolVersion: "version",
   155  			},
   156  			want: &metadata.Metadata{
   157  				ToolName:    "name",
   158  				ToolVersion: "version",
   159  			},
   160  		},
   161  	}
   162  
   163  	for _, tc := range testCases {
   164  		t.Run(tc.desc, func(t *testing.T) {
   165  			got := metadata.ToStruct(tc.m)
   166  			if diff := cmp.Diff(tc.want, got); diff != "" {
   167  				t.Errorf("ToStruct(%+v): (-want +got):\n%s", tc.m, diff)
   168  			}
   169  
   170  			if tc.m == nil {
   171  				return
   172  			}
   173  
   174  			// Test the reverse conversion for completeness.
   175  
   176  			gotP := &pb.Package{}
   177  			wantP := &pb.Package{
   178  				Metadata: &pb.Package_AsdfMetadata{
   179  					AsdfMetadata: tc.m,
   180  				},
   181  			}
   182  			got.SetProto(gotP)
   183  			opts := []cmp.Option{
   184  				protocmp.Transform(),
   185  			}
   186  			if diff := cmp.Diff(wantP, gotP, opts...); diff != "" {
   187  				t.Errorf("Metatadata{%+v}.SetProto(%+v): (-want +got):\n%s", got, wantP, diff)
   188  			}
   189  		})
   190  	}
   191  }