github.com/relnod/pegomock@v2.0.1+incompatible/modelgen/modelgen_test.go (about)

     1  // Copyright 2015 Peter Goetz
     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 modelgen_test
    16  
    17  import (
    18  	"fmt"
    19  	"sort"
    20  	"testing"
    21  
    22  	"github.com/petergtz/pegomock/model"
    23  	"github.com/petergtz/pegomock/modelgen/gomock"
    24  	"github.com/petergtz/pegomock/modelgen/loader"
    25  
    26  	"github.com/onsi/ginkgo"
    27  	. "github.com/onsi/ginkgo"
    28  	"github.com/onsi/gomega"
    29  	. "github.com/onsi/gomega"
    30  )
    31  
    32  func TestDSL(t *testing.T) {
    33  	gomega.RegisterFailHandler(ginkgo.Fail)
    34  	ginkgo.RunSpecs(t, "modelgen Suite")
    35  }
    36  
    37  type alphabetically []*model.Method
    38  
    39  func (a alphabetically) Len() int           { return len(a) }
    40  func (a alphabetically) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
    41  func (a alphabetically) Less(i, j int) bool { return a[i].Name < a[j].Name }
    42  
    43  var _ = Describe("modelgen/loader", func() {
    44  	It("generates an equivalent model as gomock/reflect does", func() {
    45  		pkgFromReflect, e := gomock.Reflect("github.com/petergtz/pegomock/test_interface", []string{"Display"})
    46  		Expect(e).NotTo(HaveOccurred())
    47  		sort.Sort(alphabetically(pkgFromReflect.Interfaces[0].Methods))
    48  
    49  		pkgFromLoader, e := loader.GenerateModel("github.com/petergtz/pegomock/test_interface", "Display")
    50  		Expect(e).NotTo(HaveOccurred())
    51  		sort.Sort(alphabetically(pkgFromLoader.Interfaces[0].Methods))
    52  
    53  		Expect(pkgFromLoader.Name).To(Equal(pkgFromReflect.Name))
    54  		Expect(pkgFromLoader.Interfaces).To(HaveLen(1))
    55  		Expect(pkgFromLoader.Interfaces[0].Name).To(Equal("Display"))
    56  
    57  		for i := range pkgFromReflect.Interfaces[0].Methods {
    58  			expectMethodsEqual(pkgFromLoader.Interfaces[0].Methods[i], pkgFromReflect.Interfaces[0].Methods[i])
    59  		}
    60  	})
    61  
    62  	It("generates a model with the basic properties", func() {
    63  		pkg, e := loader.GenerateModel("github.com/petergtz/pegomock/modelgen/test_data/default_test_interface", "Display")
    64  		Expect(e).NotTo(HaveOccurred())
    65  
    66  		Expect(pkg.Name).To(Equal("test_interface"))
    67  		Expect(pkg.Interfaces).To(HaveLen(1))
    68  		Expect(pkg.Interfaces[0].Name).To(Equal("Display"))
    69  
    70  		Expect(pkg.Interfaces[0].Methods).To(ContainElement(
    71  			&model.Method{
    72  				Name: "Show",
    73  				In: []*model.Parameter{
    74  					&model.Parameter{
    75  						Name: "_param0",
    76  						Type: model.PredeclaredType("string"),
    77  					},
    78  				},
    79  			},
    80  		))
    81  
    82  		// TODO add more test cases
    83  	})
    84  })
    85  
    86  func expectMethodsEqual(actual, expected *model.Method) {
    87  	Expect(actual.Name).To(Equal(expected.Name))
    88  	expectParamsEqual(actual.Name, actual.In, expected.In)
    89  	expectParamsEqual(actual.Name, actual.Out, expected.Out)
    90  }
    91  
    92  func expectParamsEqual(methodName string, actual, expected []*model.Parameter) {
    93  	for i := range expected {
    94  		if actual[i].Name != expected[i].Name {
    95  			fmt.Printf("Note: In method %v, param names differ \"%v\" != \"%v\"\n", methodName, actual[i].Name, expected[i].Name)
    96  		}
    97  		Expect(actual[i].Type).To(Equal(expected[i].Type))
    98  	}
    99  }