flamingo.me/flamingo-commerce/v3@v3.11.0/product/application/urlService_test.go (about)

     1  package application_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  
     8  	"flamingo.me/flamingo-commerce/v3/product/application"
     9  	"flamingo.me/flamingo-commerce/v3/product/domain"
    10  )
    11  
    12  func TestURLService_GetURLParams(t *testing.T) {
    13  
    14  	type fields struct {
    15  		config *struct {
    16  			GenerateSlug      bool   `inject:"config:commerce.product.generateSlug,optional"`
    17  			SlugAttributecode string `inject:"config:commerce.product.slugAttributeCode,optional"`
    18  		}
    19  	}
    20  	type args struct {
    21  		product     domain.BasicProduct
    22  		variantCode string
    23  	}
    24  	tests := []struct {
    25  		name   string
    26  		fields fields
    27  		args   args
    28  		want   map[string]string
    29  	}{
    30  		{
    31  			name: "nil product",
    32  			want: make(map[string]string),
    33  		},
    34  		{
    35  			name: "simple, generate slug",
    36  			fields: fields{
    37  				config: getConfig(true, "slug"),
    38  			},
    39  			args: args{
    40  				product: domain.SimpleProduct{
    41  					BasicProductData: domain.BasicProductData{
    42  						MarketPlaceCode: "test-code",
    43  						Title:           "Test Name",
    44  						Attributes: domain.Attributes{
    45  							"slug": domain.Attribute{
    46  								Code:     "slug",
    47  								RawValue: "test-slug",
    48  							},
    49  						},
    50  					},
    51  				},
    52  			},
    53  			want: map[string]string{
    54  				"marketplacecode": "test-code",
    55  				"name":            "test-name",
    56  			},
    57  		},
    58  		{
    59  			name: "simple, use slug, attribute missing",
    60  			fields: fields{
    61  				config: getConfig(false, "slug"),
    62  			},
    63  			args: args{
    64  				product: domain.SimpleProduct{
    65  					BasicProductData: domain.BasicProductData{
    66  						MarketPlaceCode: "test-code",
    67  						Title:           "Test Name",
    68  						Attributes: domain.Attributes{
    69  							"slug-invalid": domain.Attribute{
    70  								Code:     "slug",
    71  								RawValue: "test-slug",
    72  							},
    73  						},
    74  					},
    75  				},
    76  			},
    77  			want: map[string]string{
    78  				"marketplacecode": "test-code",
    79  				"name":            "test-name",
    80  			},
    81  		},
    82  		{
    83  			name: "simple, use slug, attribute empty",
    84  			fields: fields{
    85  				config: getConfig(false, "slug"),
    86  			},
    87  			args: args{
    88  				product: domain.SimpleProduct{
    89  					BasicProductData: domain.BasicProductData{
    90  						MarketPlaceCode: "test-code",
    91  						Title:           "Test Name",
    92  						Attributes: domain.Attributes{
    93  							"slug": domain.Attribute{
    94  								Code: "slug",
    95  							},
    96  						},
    97  					},
    98  				},
    99  			},
   100  			want: map[string]string{
   101  				"marketplacecode": "test-code",
   102  				"name":            "test-name",
   103  			},
   104  		},
   105  		{
   106  			name: "simple, use slug",
   107  			fields: fields{
   108  				config: getConfig(false, "slug"),
   109  			},
   110  			args: args{
   111  				product: domain.SimpleProduct{
   112  					BasicProductData: domain.BasicProductData{
   113  						MarketPlaceCode: "test-code",
   114  						Title:           "Test Name",
   115  						Attributes: domain.Attributes{
   116  							"slug": domain.Attribute{
   117  								Code:     "slug",
   118  								RawValue: "slug-test-name",
   119  							},
   120  						},
   121  					},
   122  				},
   123  			},
   124  			want: map[string]string{
   125  				"marketplacecode": "test-code",
   126  				"name":            "slug-test-name",
   127  			},
   128  		},
   129  		{
   130  			name: "configurable, use slug",
   131  			fields: fields{
   132  				config: getConfig(false, "slug"),
   133  			},
   134  			args: args{
   135  				product: domain.ConfigurableProduct{
   136  					BasicProductData: domain.BasicProductData{
   137  						MarketPlaceCode: "test-code",
   138  						Title:           "Test Name",
   139  						Attributes: domain.Attributes{
   140  							"slug": domain.Attribute{
   141  								Code:     "slug",
   142  								RawValue: "slug-test-name",
   143  							},
   144  						},
   145  					},
   146  				},
   147  			},
   148  			want: map[string]string{
   149  				"marketplacecode": "test-code",
   150  				"name":            "slug-test-name",
   151  			},
   152  		},
   153  		{
   154  			name: "configurable, active variant, use slug",
   155  			fields: fields{
   156  				config: getConfig(false, "slug"),
   157  			},
   158  			args: args{
   159  				product: domain.ConfigurableProductWithActiveVariant{
   160  					BasicProductData: domain.BasicProductData{
   161  						MarketPlaceCode: "test-code",
   162  						Title:           "Test Name",
   163  						Attributes: domain.Attributes{
   164  							"slug": domain.Attribute{
   165  								Code:     "slug",
   166  								RawValue: "slug-test-name",
   167  							},
   168  						},
   169  					},
   170  					ActiveVariant: domain.Variant{
   171  						BasicProductData: domain.BasicProductData{
   172  							MarketPlaceCode: "variant-test-code",
   173  							Title:           "Variant Name",
   174  							Attributes: domain.Attributes{
   175  								"slug": domain.Attribute{
   176  									Code:     "slug",
   177  									RawValue: "slug-variant-test-name",
   178  								},
   179  							},
   180  						},
   181  					},
   182  				},
   183  			},
   184  			want: map[string]string{
   185  				"marketplacecode": "test-code",
   186  				"name":            "slug-variant-test-name",
   187  				"variantcode":     "variant-test-code",
   188  			},
   189  		},
   190  		{
   191  			name: "configurable, active variant, withvariant code, use slug",
   192  			fields: fields{
   193  				config: getConfig(false, "slug"),
   194  			},
   195  			args: args{
   196  				product: domain.ConfigurableProductWithActiveVariant{
   197  					BasicProductData: domain.BasicProductData{
   198  						MarketPlaceCode: "test-code",
   199  						Title:           "Test Name",
   200  						Attributes: domain.Attributes{
   201  							"slug": domain.Attribute{
   202  								Code:     "slug",
   203  								RawValue: "slug-test-name",
   204  							},
   205  						},
   206  					},
   207  					Variants: []domain.Variant{
   208  						{
   209  							BasicProductData: domain.BasicProductData{
   210  								MarketPlaceCode: "selected-variant",
   211  								Title:           "Select Variant Name",
   212  								Attributes: domain.Attributes{
   213  									"slug": domain.Attribute{
   214  										Code:     "slug",
   215  										RawValue: "slug-selected-variant-test-name",
   216  									},
   217  								},
   218  							},
   219  						},
   220  					},
   221  					ActiveVariant: domain.Variant{
   222  						BasicProductData: domain.BasicProductData{
   223  							MarketPlaceCode: "variant-test-code",
   224  							Title:           "Variant Name",
   225  							Attributes: domain.Attributes{
   226  								"slug": domain.Attribute{
   227  									Code:     "slug",
   228  									RawValue: "slug-variant-test-name",
   229  								},
   230  							},
   231  						},
   232  					},
   233  				},
   234  				variantCode: "selected-variant",
   235  			},
   236  			want: map[string]string{
   237  				"marketplacecode": "test-code",
   238  				"name":            "slug-selected-variant-test-name",
   239  				"variantcode":     "selected-variant",
   240  			},
   241  		},
   242  		{
   243  			name: "configurable, with teaser, use slug, no slug on teaser set",
   244  			fields: fields{
   245  				config: getConfig(false, "slug"),
   246  			},
   247  			args: args{
   248  				product: domain.ConfigurableProduct{
   249  					BasicProductData: domain.BasicProductData{
   250  						MarketPlaceCode: "test-code",
   251  						Title:           "Test Name",
   252  					},
   253  					Variants: []domain.Variant{
   254  						{
   255  							BasicProductData: domain.BasicProductData{
   256  								MarketPlaceCode: "selected-variant",
   257  								Title:           "Select Variant Name",
   258  								Attributes: domain.Attributes{
   259  									"slug": domain.Attribute{
   260  										Code:     "slug",
   261  										RawValue: "slug-selected-variant-test-name",
   262  									},
   263  								},
   264  							},
   265  						},
   266  					},
   267  					Teaser: domain.TeaserData{
   268  						PreSelectedVariantSku: "teaser-preselected-variant",
   269  						ShortTitle:            "teaser-short-title",
   270  					},
   271  				},
   272  			},
   273  			want: map[string]string{
   274  				"marketplacecode": "test-code",
   275  				"name":            "teaser-short-title",
   276  				"variantcode":     "teaser-preselected-variant",
   277  			},
   278  		},
   279  		{
   280  			name: "configurable, with teaser, use slug, no slug on teaser set",
   281  			fields: fields{
   282  				config: getConfig(false, "slug"),
   283  			},
   284  			args: args{
   285  				product: domain.ConfigurableProduct{
   286  					BasicProductData: domain.BasicProductData{
   287  						MarketPlaceCode: "test-code",
   288  						Title:           "Test Name",
   289  					},
   290  					Variants: []domain.Variant{
   291  						{
   292  							BasicProductData: domain.BasicProductData{
   293  								MarketPlaceCode: "selected-variant",
   294  								Title:           "Select Variant Name",
   295  								Attributes: domain.Attributes{
   296  									"slug": domain.Attribute{
   297  										Code:     "slug",
   298  										RawValue: "slug-selected-variant-test-name",
   299  									},
   300  								},
   301  							},
   302  						},
   303  					},
   304  					Teaser: domain.TeaserData{
   305  						PreSelectedVariantSku: "teaser-preselected-variant",
   306  						ShortTitle:            "teaser-short-title",
   307  						URLSlug:               "teaser-url-slug",
   308  					},
   309  				},
   310  			},
   311  			want: map[string]string{
   312  				"marketplacecode": "test-code",
   313  				"name":            "teaser-url-slug",
   314  				"variantcode":     "teaser-preselected-variant",
   315  			},
   316  		},
   317  		{
   318  			name: "configurable, variant set, use slug",
   319  			fields: fields{
   320  				config: getConfig(false, "slug"),
   321  			},
   322  			args: args{
   323  				product: domain.ConfigurableProduct{
   324  					BasicProductData: domain.BasicProductData{
   325  						MarketPlaceCode: "test-code",
   326  						Title:           "Test Name",
   327  					},
   328  					Variants: []domain.Variant{
   329  						{
   330  							BasicProductData: domain.BasicProductData{
   331  								MarketPlaceCode: "selected-variant",
   332  								Title:           "Select Variant Name",
   333  								Attributes: domain.Attributes{
   334  									"slug": domain.Attribute{
   335  										Code:     "slug",
   336  										RawValue: "slug-selected-variant-test-name",
   337  									},
   338  								},
   339  							},
   340  						},
   341  					},
   342  				},
   343  				variantCode: "selected-variant",
   344  			},
   345  			want: map[string]string{
   346  				"marketplacecode": "test-code",
   347  				"name":            "slug-selected-variant-test-name",
   348  				"variantcode":     "selected-variant",
   349  			},
   350  		},
   351  	}
   352  	for _, tt := range tests {
   353  		t.Run(tt.name, func(t *testing.T) {
   354  			s := &application.URLService{}
   355  			s.Inject(
   356  				nil,
   357  				tt.fields.config,
   358  			)
   359  			got := s.GetURLParams(tt.args.product, tt.args.variantCode)
   360  			assert.Equal(t, tt.want, got, "url params")
   361  		})
   362  	}
   363  }
   364  
   365  func getConfig(generate bool, code string) *struct {
   366  	GenerateSlug      bool   `inject:"config:commerce.product.generateSlug,optional"`
   367  	SlugAttributecode string `inject:"config:commerce.product.slugAttributeCode,optional"`
   368  } {
   369  
   370  	return &struct {
   371  		GenerateSlug      bool   `inject:"config:commerce.product.generateSlug,optional"`
   372  		SlugAttributecode string `inject:"config:commerce.product.slugAttributeCode,optional"`
   373  	}{
   374  		GenerateSlug:      generate,
   375  		SlugAttributecode: code,
   376  	}
   377  }