github.com/mailru/activerecord@v1.12.2/internal/pkg/generator/tmpl/octopus/fixture.tmpl (about)

     1  package {{ .ARPkg }}
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"fmt"
     7  	"log"
     8  {{ if eq .Server.Conf "" -}}
     9  	"time"
    10  {{ end }}
    11  	"strings"
    12  
    13      "gopkg.in/yaml.v3"
    14  
    15  	"github.com/mailru/activerecord/pkg/activerecord"
    16  	"github.com/mailru/activerecord/pkg/octopus"
    17  {{- range $ind, $imp := .Imports }}
    18  	{{ if ne $imp.ImportName "" }}{{ $imp.ImportName }} {{ end }}"{{ $imp.Path }}"
    19  {{- end }}
    20  {{- range $i, $imp := addImport .FieldList }}
    21  	"{{ $imp }}"
    22  {{- end }}
    23  )
    24  {{ $pkgName := .ARPkg }}
    25  {{ $serializers := .Serializers -}}
    26  {{ $PublicStructName := .ARPkgTitle -}}
    27  {{ $fields := .FieldList }}
    28  {{ $procfields := .ProcOutFieldList }}
    29  {{ $procInLen := len .ProcInFieldList }}
    30  {{ $typePK := "" -}}
    31  {{ $fieldNamePK := "" -}}
    32  
    33  {{ if $procfields }}
    34  type {{ $PublicStructName }}FTPK struct {
    35      {{- range $ind, $fstruct := .ProcInFieldList }}
    36          {{ $rtype := $fstruct.Format -}}
    37          {{ $serlen := len $fstruct.Serializer -}}
    38          {{ if ne $serlen 0 -}}
    39              {{ $sname := index $fstruct.Serializer 0 -}}
    40              {{ $serializer := index $serializers $sname -}}
    41              {{ $rtype = $serializer.Type -}}
    42          {{ end }}
    43  	    {{ $fstruct.Name }} {{ $rtype -}} `yaml:"{{ $fstruct.Name | snakeCase -}}" mapstructure:"{{ $fstruct.Name | snakeCase -}}" json:"{{ $fstruct.Name | snakeCase -}}"`
    44  	{{- end }}
    45  }
    46  
    47  type {{ $PublicStructName }}FT struct {
    48      Params {{ $PublicStructName }}FTPK `yaml:"params"`
    49  {{- range $ind, $fstruct := .ProcOutFieldList -}}
    50  	{{ $rtype := $fstruct.Format -}}
    51  	{{ $serlen := len $fstruct.Serializer -}}
    52  	{{ if ne $serlen 0 -}}
    53  		{{ $sname := index $fstruct.Serializer 0 -}}
    54  		{{ $serializer := index $serializers $sname -}}
    55  		{{ $rtype = $serializer.Type -}}
    56  	{{ end }}
    57  	{{ $fstruct.Name }} {{ $rtype -}} `yaml:"{{ $fstruct.Name | snakeCase -}}"`
    58  {{- end }}
    59  }
    60  
    61  func MarshalFixtures(objs []*{{$PublicStructName}}) ([]byte, error) {
    62  	fts := make([]{{$PublicStructName}}FT, 0, len(objs))
    63  	for _, obj := range objs {
    64          {{ if ne $procInLen 0 }}params := obj.GetParams(){{ end }}
    65  
    66          pk := {{$PublicStructName}}FTPK{
    67              {{- range $ind, $fstruct := .ProcInFieldList }}
    68                  {{$fstruct.Name}}: params.{{$fstruct.Name}},
    69              {{- end }}
    70          }
    71  		fts = append(fts, {{$PublicStructName}}FT{
    72  		    Params: pk,
    73              {{- range $ind, $fstruct := .ProcOutFieldList }}
    74  			{{$fstruct.Name}}: obj.Get{{$fstruct.Name}}(),
    75  			{{- end }}
    76  		})
    77  	}
    78  	return yaml.Marshal(fts)
    79  }
    80  
    81  func UnmarshalFromYaml(source []byte) []*{{$PublicStructName}} {
    82      var fixtures []{{$PublicStructName}}FT
    83  
    84      if err := yaml.Unmarshal(source, &fixtures); err != nil {
    85          log.Fatalf("unmarshal {{$PublicStructName}}FT fixture: %v", err)
    86      }
    87  
    88      objs := make([]*{{$PublicStructName}}, 0, len(fixtures))
    89  
    90      for _, ft := range fixtures {
    91  
    92          o := New(context.Background())
    93          o.setParams({{$PublicStructName}}Params{
    94              {{- range $ind, $fstruct := .ProcInFieldList }}
    95              {{$fstruct.Name}}: ft.Params.{{$fstruct.Name}},
    96              {{- end }}
    97          })
    98  
    99          {{- range $ind, $fstruct := .ProcOutFieldList }}
   100          if err := o.Set{{$fstruct.Name}}(ft.{{$fstruct.Name}}); err != nil {
   101              log.Fatalf("can't set value %v to field {{$fstruct.Name}} of {{$PublicStructName}} fixture: %s", ft.{{$fstruct.Name}}, err)
   102          }
   103          {{- end }}
   104  
   105          objs = append(objs, o)
   106      }
   107  
   108      return objs
   109  }
   110  
   111  func UnmarshalFixtures(source []byte) ([]{{$PublicStructName}}FT, error) {
   112  	source = bytes.TrimLeft(source, " \t\r\n")
   113  
   114  	if  len(source) > 0 && source[0] == '{' {
   115  		source = []byte(fmt.Sprintf("[%s]", string(source)))
   116  	}
   117  
   118  	var v []{{$PublicStructName}}FT
   119  
   120  	if err := json.Unmarshal([]byte(source), &v); err != nil {
   121  		return nil, err
   122  	}
   123  
   124  	return v, nil
   125  }
   126  {{ end }}
   127  
   128  func (objs {{$PublicStructName}}List) String() string {
   129  	o, err := MarshalFixtures(objs)
   130  	if err != nil {
   131  		activerecord.Logger().Fatal(context.Background(), err)
   132  	}
   133  	return string(o)
   134  }
   135  
   136  {{ if $fields }}
   137  {{ range $num, $ind := .Indexes -}}
   138  {{ $lenfld := len $ind.Fields -}}
   139  	{{ if $ind.Primary }}
   140          {{ if ne $lenfld 1 }}
   141          {{ $typePK = print $pkgName "." $ind.Type }}
   142          {{ else }}
   143          {{- $typePK = $ind.Type -}}
   144          {{ end }}
   145          {{- $fieldNamePK = $ind.Name -}}
   146      {{ end }}
   147  {{ end }}
   148  
   149  type {{ $PublicStructName }}FT struct {
   150  {{- range $ind, $fstruct := .FieldList -}}
   151  	{{ $rtype := $fstruct.Format -}}
   152  	{{ $serlen := len $fstruct.Serializer -}}
   153  	{{ if ne $serlen 0 -}}
   154  		{{ $sname := index $fstruct.Serializer 0 -}}
   155  		{{ $serializer := index $serializers $sname -}}
   156  		{{ $rtype = $serializer.Type -}}
   157  	{{ end }}
   158  	{{ $fstruct.Name }} {{ $rtype -}} `yaml:"{{ $fstruct.Name | snakeCase -}}" mapstructure:"{{ $fstruct.Name | snakeCase -}}" json:"{{ $fstruct.Name | snakeCase -}}"`
   159  {{- end }}
   160  }
   161  
   162  func UnmarshalFixtures(source []byte) ([]{{$PublicStructName}}FT, error) {
   163  	source = bytes.TrimLeft(source, " \t\r\n")
   164  
   165  	if  len(source) > 0 && source[0] == '{' {
   166  		source = []byte(fmt.Sprintf("[%s]", string(source)))
   167  	}
   168  
   169  	var v []{{$PublicStructName}}FT
   170  
   171  	if err := json.Unmarshal([]byte(source), &v); err != nil {
   172  		return nil, err
   173  	}
   174  
   175  	return v, nil
   176  }
   177  
   178  func MarshalFixtures(objs []*{{$PublicStructName}}) ([]byte, error) {
   179  	fts := make([]{{$PublicStructName}}FT, 0, len(objs))
   180  	for _, obj := range objs {
   181  		fts = append(fts, {{$PublicStructName}}FT{
   182              {{- range $ind, $fstruct := .FieldList }}
   183  			{{$fstruct.Name}}: obj.Get{{$fstruct.Name}}(),
   184  			{{- end }}
   185  		})
   186  	}
   187  	return yaml.Marshal(fts)
   188  }
   189  
   190  func UnmarshalFromYaml(source []byte) []*{{$PublicStructName}} {
   191      var fixtures []{{$PublicStructName}}FT
   192  
   193      if err := yaml.Unmarshal(source, &fixtures); err != nil {
   194          log.Fatalf("unmarshal {{$PublicStructName}}FT fixture: %v", err)
   195      }
   196  
   197      objs := make([]*{{$PublicStructName}}, 0, len(fixtures))
   198  
   199      for _, ft := range fixtures {
   200  
   201          o := New(context.Background())
   202          {{- range $ind, $fstruct := .FieldList }}
   203          if err := o.Set{{$fstruct.Name}}(ft.{{$fstruct.Name}}); err != nil {
   204              log.Fatalf("can't set value %v to field {{$fstruct.Name}} of {{$PublicStructName}} fixture: %s", ft.{{$fstruct.Name}}, err)
   205          }
   206          {{- end }}
   207  
   208          objs = append(objs, o)
   209      }
   210  
   211      return objs
   212  }
   213  
   214  {{/* Отдельный тип фикстур, чтобы не было пересечения по PrimaryKey для update, select, delete... фикстур в yaml */}}
   215  type  {{ $PublicStructName }}UpdateFT struct {
   216  {{- range $ind, $fstruct := .FieldList -}}
   217      {{ if eq $fstruct.Name $fieldNamePK }}
   218          {{ $rtype := $fstruct.Format -}}
   219          {{ $serlen := len $fstruct.Serializer -}}
   220          {{ if ne $serlen 0 -}}
   221              {{ $sname := index $fstruct.Serializer 0 -}}
   222              {{ $serializer := index $serializers $sname -}}
   223              {{ $rtype = $serializer.Type -}}
   224          {{ end }}
   225          {{ $fstruct.Name }} {{ $rtype -}} `yaml:"{{ $fstruct.Name | snakeCase -}}"`
   226      {{ end }}
   227  {{- end }}
   228  	UpdateOptions []{{ $PublicStructName }}UpdateFixtureOptions `yaml:"update_options"`
   229  }
   230  
   231  type {{ $PublicStructName }}UpdateFixtureOptions struct {
   232  	{{/* Generate option for each not primary field */}}
   233      {{- range $ind, $fstruct := .FieldList -}}
   234          {{ if ne $fstruct.Name $fieldNamePK }}
   235              {{ $rtype := $fstruct.Format -}}
   236              {{ $serlen := len $fstruct.Serializer -}}
   237              {{ if ne $serlen 0 -}}
   238                  {{ $sname := index $fstruct.Serializer 0 -}}
   239                  {{ $serializer := index $serializers $sname -}}
   240                  {{ $rtype = $serializer.Type -}}
   241              {{ end }}
   242  
   243              {{$fstruct.Name}} *{{$PublicStructName}}{{$fstruct.Name}}UpdateFixtureOption `yaml:"{{ $fstruct.Name | snakeCase -}}"`
   244          {{ end }}
   245      {{- end }}
   246  }
   247  
   248  {{/* Generate options struct for each not primary field */}}
   249  {{- range $ind, $fstruct := .FieldList -}}
   250      {{ if ne $fstruct.Name $fieldNamePK }}
   251          {{ $rtype := $fstruct.Format -}}
   252          {{ $serlen := len $fstruct.Serializer -}}
   253          {{ if ne $serlen 0 -}}
   254              {{ $sname := index $fstruct.Serializer 0 -}}
   255              {{ $serializer := index $serializers $sname -}}
   256              {{ $rtype = $serializer.Type -}}
   257          {{ end }}
   258  
   259          type {{$PublicStructName}}{{$fstruct.Name}}UpdateFixtureOption struct {
   260              Value {{ $rtype -}} `yaml:"set_value"`
   261          }
   262      {{ end }}
   263  {{- end }}
   264  
   265  func UnmarshalUpdateFromYaml(source []byte) []*{{$PublicStructName}} {
   266      var fixtures []{{$PublicStructName}}UpdateFT
   267  
   268      if err := yaml.Unmarshal(source, &fixtures); err != nil {
   269          log.Fatalf("unmarshal {{$PublicStructName}}UpdateFT fixture: %v", err)
   270      }
   271  
   272      objs := make([]*{{$PublicStructName}}, 0, len(fixtures))
   273  
   274      for _, ft := range fixtures {
   275          obj := New(context.Background())
   276  
   277          {{ range $num, $ind := .Indexes -}}
   278              {{ $lenfld := len $ind.Fields }}
   279                  {{ if $ind.Primary }}
   280                      {{ if eq $lenfld 1 }}
   281                          if err := obj.Set{{ $fieldNamePK }}(ft.{{ $fieldNamePK }}); err != nil {
   282                               log.Fatalf("error Set{{ $fieldNamePK }}: %v", err)
   283                          }
   284                          obj.BaseField.Exists = true
   285                          obj.BaseField.UpdateOps = []octopus.Ops{}
   286                      {{ end }}
   287                  {{ end }}
   288              {{ end }}
   289  
   290          SetFixtureUpdateOptions(obj, ft.UpdateOptions)
   291  
   292          objs = append(objs, obj)
   293      }
   294  
   295      return objs
   296  }
   297  
   298  func UnmarshalInsertReplaceFromYaml(source []byte) []*{{$PublicStructName}} {
   299      return UnmarshalFromYaml(source)
   300  }
   301  
   302  func SetFixtureUpdateOptions(obj *{{$PublicStructName}}, updateOptions  []{{$PublicStructName}}UpdateFixtureOptions) {
   303      for priority, updateOption := range updateOptions {
   304      {{- range $ind, $fstruct := .FieldList }}
   305          {{/* Skip primary key field */}}
   306          {{ if ne $fstruct.Name $fieldNamePK }}
   307              // Если опции нет, то ее нет в списке на установку
   308              if updateOption.{{$fstruct.Name}} != nil {
   309                  if err := obj.Set{{$fstruct.Name}}(updateOption.{{$fstruct.Name}}.Value); err != nil {
   310                      log.Fatalf("Set{{$fstruct.Name}}[priority: %d] error: %v", priority, err)
   311                  }
   312              }
   313          {{ end }}
   314      {{- end }}
   315      }
   316  }
   317  {{ end }}
   318  
   319  func UnmarshalDeleteFromYaml(source []byte) []*{{$PublicStructName}} {
   320  	return UnmarshalFromYaml(source)
   321  }