github.com/lukasheimann/cloudfoundrycli@v7.1.0+incompatible/command/translatableerror/tip_decorator_error_test.go (about)

     1  package translatableerror_test
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  
     7  	. "code.cloudfoundry.org/cli/command/translatableerror"
     8  	"code.cloudfoundry.org/cli/command/translatableerror/translatableerrorfakes"
     9  	. "github.com/onsi/ginkgo"
    10  	. "github.com/onsi/gomega"
    11  )
    12  
    13  type TranslateSpy struct {
    14  	wasTranslateCalled bool
    15  	calls              []struct {
    16  		text string
    17  		keys []interface{}
    18  	}
    19  }
    20  
    21  func (spy *TranslateSpy) translate(s string, v ...interface{}) string {
    22  	spy.wasTranslateCalled = true
    23  	spy.calls = append(spy.calls, struct {
    24  		text string
    25  		keys []interface{}
    26  	}{text: s, keys: v})
    27  
    28  	return fmt.Sprintf("Translate Called: %s", s)
    29  }
    30  
    31  func (spy TranslateSpy) translateArgsForCall(i int) (string, []interface{}) {
    32  	return spy.calls[i].text, spy.calls[i].keys
    33  }
    34  
    35  var _ = Describe("TipDecoratorError", func() {
    36  	Describe("Translate()", func() {
    37  		var (
    38  			tip    TipDecoratorError
    39  			output string
    40  
    41  			spy TranslateSpy
    42  		)
    43  
    44  		BeforeEach(func() {
    45  			tip = TipDecoratorError{
    46  				Tip: "I am a {{.Foo}}",
    47  				TipKeys: map[string]interface{}{
    48  					"Foo": "tip",
    49  				},
    50  			}
    51  			spy = TranslateSpy{}
    52  		})
    53  
    54  		JustBeforeEach(func() {
    55  			output = tip.Translate(spy.translate)
    56  		})
    57  
    58  		When("the base error is translatable error", func() {
    59  			var fakeErr *translatableerrorfakes.FakeTranslatableError
    60  
    61  			BeforeEach(func() {
    62  				fakeErr = new(translatableerrorfakes.FakeTranslatableError)
    63  				fakeErr.TranslateReturns("some translated error")
    64  
    65  				tip.BaseError = fakeErr
    66  			})
    67  
    68  			It("translates the base error", func() {
    69  				Expect(fakeErr.TranslateCallCount()).To(Equal(1))
    70  			})
    71  
    72  			It("has output", func() {
    73  				Expect(output).To(Equal("Translate Called: {{.BaseError}}\n\nTIP: {{.Tip}}"))
    74  			})
    75  
    76  			It("calls translate 2 times", func() {
    77  				Expect(spy.calls).To(HaveLen(2))
    78  				Expect(spy.calls[0].keys).To(ConsistOf(tip.TipKeys))
    79  				Expect(spy.calls[1].keys).To(ConsistOf(map[string]interface{}{
    80  					"BaseError": "some translated error",
    81  					"Tip":       "Translate Called: I am a {{.Foo}}",
    82  				}))
    83  			})
    84  		})
    85  
    86  		When("the base error is a generic error", func() {
    87  			var genericError error
    88  
    89  			BeforeEach(func() {
    90  				genericError = errors.New("I am an error")
    91  				tip.BaseError = genericError
    92  			})
    93  
    94  			It("translates the tip", func() {
    95  				Expect(spy.wasTranslateCalled).To(BeTrue())
    96  				actualFormatString, actualFormatKeys := spy.translateArgsForCall(0)
    97  
    98  				Expect(actualFormatString).To(Equal("I am a {{.Foo}}"))
    99  				Expect(actualFormatKeys).To(ConsistOf(map[string]interface{}{
   100  					"Foo": "tip",
   101  				}))
   102  			})
   103  
   104  			It("has output", func() {
   105  				Expect(output).To(Equal("Translate Called: {{.BaseError}}\n\nTIP: {{.Tip}}"))
   106  			})
   107  
   108  			It("calls translate 2 times", func() {
   109  				Expect(spy.calls).To(HaveLen(2))
   110  				Expect(spy.calls[0].keys).To(ConsistOf(tip.TipKeys))
   111  				Expect(spy.calls[1].keys).To(ConsistOf(map[string]interface{}{
   112  					"BaseError": "I am an error",
   113  					"Tip":       "Translate Called: I am a {{.Foo}}",
   114  				}))
   115  			})
   116  		})
   117  	})
   118  })