github.com/axw/juju@v0.0.0-20161005053422-4bd6544d08d4/resource/context/utils_test.go (about)

     1  // Copyright 2016 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package context_test
     5  
     6  import (
     7  	"bytes"
     8  	"io"
     9  	"os"
    10  	"strings"
    11  
    12  	"github.com/juju/errors"
    13  	"github.com/juju/testing"
    14  	jc "github.com/juju/testing/checkers"
    15  	"github.com/juju/testing/filetesting"
    16  	gc "gopkg.in/check.v1"
    17  	charmresource "gopkg.in/juju/charm.v6-unstable/resource"
    18  
    19  	"github.com/juju/juju/resource/context"
    20  )
    21  
    22  var _ = gc.Suite(&UtilsSuite{})
    23  
    24  type UtilsSuite struct {
    25  	testing.IsolationSuite
    26  
    27  	stub    *testing.Stub
    28  	matcher *stubMatcher
    29  }
    30  
    31  func (s *UtilsSuite) SetUpTest(c *gc.C) {
    32  	s.IsolationSuite.SetUpTest(c)
    33  
    34  	s.stub = &testing.Stub{}
    35  	s.matcher = &stubMatcher{stub: s.stub}
    36  }
    37  
    38  func (s *UtilsSuite) newReader(c *gc.C, content string) (io.ReadCloser, charmresource.Fingerprint) {
    39  	r := filetesting.NewStubFile(s.stub, bytes.NewBufferString(content))
    40  
    41  	tmpReader := strings.NewReader(content)
    42  	fp, err := charmresource.GenerateFingerprint(tmpReader)
    43  	c.Assert(err, jc.ErrorIsNil)
    44  
    45  	return r, fp
    46  }
    47  
    48  func (s *UtilsSuite) TestFingerprintMatchesOkay(c *gc.C) {
    49  	r, expected := s.newReader(c, "spam")
    50  	s.matcher.ReturnOpen = r
    51  	s.matcher.ReturnGenerateFingerprint = expected
    52  	matcher := context.FingerprintMatcher{
    53  		Open:                s.matcher.Open,
    54  		GenerateFingerprint: s.matcher.GenerateFingerprint,
    55  	}
    56  
    57  	matches, err := matcher.FingerprintMatches("some/filename.txt", expected)
    58  	c.Assert(err, jc.ErrorIsNil)
    59  
    60  	c.Check(matches, jc.IsTrue)
    61  }
    62  
    63  func (s *UtilsSuite) TestFingerprintMatchesDepCalls(c *gc.C) {
    64  	r, expected := s.newReader(c, "spam")
    65  	s.matcher.ReturnOpen = r
    66  	s.matcher.ReturnGenerateFingerprint = expected
    67  	matcher := context.FingerprintMatcher{
    68  		Open:                s.matcher.Open,
    69  		GenerateFingerprint: s.matcher.GenerateFingerprint,
    70  	}
    71  
    72  	matches, err := matcher.FingerprintMatches("some/filename.txt", expected)
    73  	c.Assert(matches, jc.IsTrue)
    74  	c.Assert(err, jc.ErrorIsNil)
    75  
    76  	s.stub.CheckCallNames(c, "Open", "GenerateFingerprint", "Close")
    77  	s.stub.CheckCall(c, 0, "Open", "some/filename.txt")
    78  	s.stub.CheckCall(c, 1, "GenerateFingerprint", r)
    79  }
    80  
    81  func (s *UtilsSuite) TestFingerprintMatchesNotFound(c *gc.C) {
    82  	_, expected := s.newReader(c, "spam")
    83  	matcher := context.FingerprintMatcher{
    84  		Open: s.matcher.Open,
    85  	}
    86  	s.stub.SetErrors(os.ErrNotExist)
    87  
    88  	matches, err := matcher.FingerprintMatches("some/filename.txt", expected)
    89  	c.Assert(err, jc.ErrorIsNil)
    90  
    91  	c.Check(matches, jc.IsFalse)
    92  	s.stub.CheckCallNames(c, "Open")
    93  }
    94  
    95  func (s *UtilsSuite) TestFingerprintMatchesOpenFailed(c *gc.C) {
    96  	_, expected := s.newReader(c, "spam")
    97  	matcher := context.FingerprintMatcher{
    98  		Open: s.matcher.Open,
    99  	}
   100  	failure := errors.New("<failed>")
   101  	s.stub.SetErrors(failure)
   102  
   103  	_, err := matcher.FingerprintMatches("some/filename.txt", expected)
   104  
   105  	c.Check(errors.Cause(err), gc.Equals, failure)
   106  	s.stub.CheckCallNames(c, "Open")
   107  }
   108  
   109  func (s *UtilsSuite) TestFingerprintMatchesGenerateFingerprintFailed(c *gc.C) {
   110  	r, expected := s.newReader(c, "spam")
   111  	s.matcher.ReturnOpen = r
   112  	matcher := context.FingerprintMatcher{
   113  		Open:                s.matcher.Open,
   114  		GenerateFingerprint: s.matcher.GenerateFingerprint,
   115  	}
   116  	failure := errors.New("<failed>")
   117  	s.stub.SetErrors(nil, failure)
   118  
   119  	_, err := matcher.FingerprintMatches("some/filename.txt", expected)
   120  
   121  	c.Check(errors.Cause(err), gc.Equals, failure)
   122  	s.stub.CheckCallNames(c, "Open", "GenerateFingerprint", "Close")
   123  }
   124  
   125  type stubMatcher struct {
   126  	stub *testing.Stub
   127  
   128  	ReturnOpen                io.ReadCloser
   129  	ReturnGenerateFingerprint charmresource.Fingerprint
   130  }
   131  
   132  func (s *stubMatcher) Open(filename string) (io.ReadCloser, error) {
   133  	s.stub.AddCall("Open", filename)
   134  	if err := s.stub.NextErr(); err != nil {
   135  		return nil, errors.Trace(err)
   136  	}
   137  
   138  	return s.ReturnOpen, nil
   139  }
   140  
   141  func (s *stubMatcher) GenerateFingerprint(r io.Reader) (charmresource.Fingerprint, error) {
   142  	s.stub.AddCall("GenerateFingerprint", r)
   143  	if err := s.stub.NextErr(); err != nil {
   144  		return charmresource.Fingerprint{}, errors.Trace(err)
   145  	}
   146  
   147  	return s.ReturnGenerateFingerprint, nil
   148  }