github.com/yoheimuta/protolint@v0.49.8-0.20240515023657-4ecaebb7575d/internal/addon/rules/messageNamesUpperCamelCaseRule_test.go (about)

     1  package rules_test
     2  
     3  import (
     4  	"reflect"
     5  	"testing"
     6  
     7  	"github.com/yoheimuta/go-protoparser/v4/parser"
     8  	"github.com/yoheimuta/go-protoparser/v4/parser/meta"
     9  
    10  	"github.com/yoheimuta/protolint/internal/addon/rules"
    11  	"github.com/yoheimuta/protolint/linter/autodisable"
    12  	"github.com/yoheimuta/protolint/linter/report"
    13  	"github.com/yoheimuta/protolint/linter/rule"
    14  )
    15  
    16  func TestMessageNamesUpperCamelCaseRule_Apply(t *testing.T) {
    17  	tests := []struct {
    18  		name         string
    19  		inputProto   *parser.Proto
    20  		wantFailures []report.Failure
    21  	}{
    22  		{
    23  			name: "no failures for proto without message",
    24  			inputProto: &parser.Proto{
    25  				ProtoBody: []parser.Visitee{
    26  					&parser.Service{},
    27  				},
    28  			},
    29  		},
    30  		{
    31  			name: "no failures for proto with valid message names",
    32  			inputProto: &parser.Proto{
    33  				ProtoBody: []parser.Visitee{
    34  					&parser.Service{},
    35  					&parser.Message{
    36  						MessageName: "MessageName",
    37  						MessageBody: []parser.Visitee{
    38  							&parser.Message{
    39  								MessageName: "InnerMessageName",
    40  							},
    41  						},
    42  					},
    43  					&parser.Message{
    44  						MessageName: "MessageName2",
    45  					},
    46  				},
    47  			},
    48  		},
    49  		{
    50  			name: "failures for proto with invalid message names",
    51  			inputProto: &parser.Proto{
    52  				ProtoBody: []parser.Visitee{
    53  					&parser.Service{},
    54  					&parser.Message{
    55  						MessageName: "messageName",
    56  						MessageBody: []parser.Visitee{
    57  							&parser.Message{
    58  								MessageName: "Inner_MessageName",
    59  								Meta: meta.Meta{
    60  									Pos: meta.Position{
    61  										Filename: "example.proto",
    62  										Offset:   150,
    63  										Line:     7,
    64  										Column:   15,
    65  									},
    66  								},
    67  							},
    68  						},
    69  						Meta: meta.Meta{
    70  							Pos: meta.Position{
    71  								Filename: "example.proto",
    72  								Offset:   100,
    73  								Line:     5,
    74  								Column:   10,
    75  							},
    76  						},
    77  					},
    78  					&parser.Message{
    79  						MessageName: "Message_name",
    80  						Meta: meta.Meta{
    81  							Pos: meta.Position{
    82  								Filename: "example.proto",
    83  								Offset:   200,
    84  								Line:     10,
    85  								Column:   20,
    86  							},
    87  						},
    88  					},
    89  				},
    90  			},
    91  			wantFailures: []report.Failure{
    92  				report.Failuref(
    93  					meta.Position{
    94  						Filename: "example.proto",
    95  						Offset:   100,
    96  						Line:     5,
    97  						Column:   10,
    98  					},
    99  					"MESSAGE_NAMES_UPPER_CAMEL_CASE",
   100  					`Message name "messageName" must be UpperCamelCase like "MessageName"`,
   101  				),
   102  				report.Failuref(
   103  					meta.Position{
   104  						Filename: "example.proto",
   105  						Offset:   150,
   106  						Line:     7,
   107  						Column:   15,
   108  					},
   109  					"MESSAGE_NAMES_UPPER_CAMEL_CASE",
   110  					`Message name "Inner_MessageName" must be UpperCamelCase like "InnerMessageName"`,
   111  				),
   112  				report.Failuref(
   113  					meta.Position{
   114  						Filename: "example.proto",
   115  						Offset:   200,
   116  						Line:     10,
   117  						Column:   20,
   118  					},
   119  					"MESSAGE_NAMES_UPPER_CAMEL_CASE",
   120  					`Message name "Message_name" must be UpperCamelCase like "MessageName"`,
   121  				),
   122  			},
   123  		},
   124  	}
   125  
   126  	for _, test := range tests {
   127  		test := test
   128  		t.Run(test.name, func(t *testing.T) {
   129  			rule := rules.NewMessageNamesUpperCamelCaseRule(rule.SeverityError, false, autodisable.Noop)
   130  
   131  			got, err := rule.Apply(test.inputProto)
   132  			if err != nil {
   133  				t.Errorf("got err %v, but want nil", err)
   134  				return
   135  			}
   136  			if !reflect.DeepEqual(got, test.wantFailures) {
   137  				t.Errorf("got %v, but want %v", got, test.wantFailures)
   138  			}
   139  		})
   140  	}
   141  }
   142  
   143  func TestMessageNamesUpperCamelCaseRule_Apply_fix(t *testing.T) {
   144  	tests := []struct {
   145  		name          string
   146  		inputFilename string
   147  		wantFilename  string
   148  	}{
   149  		{
   150  			name:          "no fix for a correct proto",
   151  			inputFilename: "upperCamelCase.proto",
   152  			wantFilename:  "upperCamelCase.proto",
   153  		},
   154  		{
   155  			name:          "fix for an incorrect proto",
   156  			inputFilename: "invalid.proto",
   157  			wantFilename:  "upperCamelCase.proto",
   158  		},
   159  	}
   160  
   161  	for _, test := range tests {
   162  		test := test
   163  		t.Run(test.name, func(t *testing.T) {
   164  			r := rules.NewMessageNamesUpperCamelCaseRule(rule.SeverityError, true, autodisable.Noop)
   165  			testApplyFix(t, r, test.inputFilename, test.wantFilename)
   166  		})
   167  	}
   168  }
   169  
   170  func TestMessageNamesUpperCamelCaseRule_Apply_disable(t *testing.T) {
   171  	tests := []struct {
   172  		name               string
   173  		inputFilename      string
   174  		inputPlacementType autodisable.PlacementType
   175  		wantFilename       string
   176  	}{
   177  		{
   178  			name:          "do nothing in case of no violations",
   179  			inputFilename: "upperCamelCase.proto",
   180  			wantFilename:  "upperCamelCase.proto",
   181  		},
   182  		{
   183  			name:               "insert disable:next comments",
   184  			inputFilename:      "invalid.proto",
   185  			inputPlacementType: autodisable.Next,
   186  			wantFilename:       "disable_next.proto",
   187  		},
   188  		{
   189  			name:               "insert disable:this comments",
   190  			inputFilename:      "invalid.proto",
   191  			inputPlacementType: autodisable.ThisThenNext,
   192  			wantFilename:       "disable_this.proto",
   193  		},
   194  	}
   195  
   196  	for _, test := range tests {
   197  		test := test
   198  		t.Run(test.name, func(t *testing.T) {
   199  			r := rules.NewMessageNamesUpperCamelCaseRule(rule.SeverityError, true, test.inputPlacementType)
   200  			testApplyFix(t, r, test.inputFilename, test.wantFilename)
   201  		})
   202  	}
   203  }