github.com/niedbalski/juju@v0.0.0-20190215020005-8ff100488e47/mongo/internal_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  // +build !windows
     5  
     6  package mongo
     7  
     8  import (
     9  	"errors"
    10  	"os"
    11  	"time"
    12  
    13  	jc "github.com/juju/testing/checkers"
    14  	gc "gopkg.in/check.v1"
    15  
    16  	coretesting "github.com/juju/juju/testing"
    17  )
    18  
    19  type MongoVersionSuite struct {
    20  	coretesting.BaseSuite
    21  }
    22  
    23  type MongoPathSuite struct {
    24  	coretesting.BaseSuite
    25  }
    26  
    27  var _ = gc.Suite(&MongoVersionSuite{})
    28  var _ = gc.Suite(&MongoPathSuite{})
    29  
    30  var (
    31  	version1   = Version{Major: 1, Minor: 0}
    32  	version1d1 = Version{Major: 1, Minor: 1}
    33  	version2   = Version{Major: 2, Minor: 0}
    34  )
    35  
    36  func (m *MongoVersionSuite) TestVersionNewerCompareMinors(c *gc.C) {
    37  	res := version1.NewerThan(version1d1)
    38  	c.Assert(res, gc.Equals, -1)
    39  	res = version1d1.NewerThan(version1)
    40  	c.Assert(res, gc.Equals, 1)
    41  	res = version1.NewerThan(version1)
    42  	c.Assert(res, gc.Equals, 0)
    43  }
    44  
    45  func (m *MongoVersionSuite) TestVersionNewerCompareMayors(c *gc.C) {
    46  	res := version1.NewerThan(version2)
    47  	c.Assert(res, gc.Equals, -1)
    48  	res = version2.NewerThan(version1)
    49  	c.Assert(res, gc.Equals, 1)
    50  	res = version2.NewerThan(version1d1)
    51  	c.Assert(res, gc.Equals, 1)
    52  }
    53  
    54  func (m *MongoVersionSuite) TestVersionNewerCompareSpecial(c *gc.C) {
    55  	res := MongoUpgrade.NewerThan(version2)
    56  	c.Assert(res, gc.Equals, 0)
    57  	res = version2.NewerThan(MongoUpgrade)
    58  	c.Assert(res, gc.Equals, 0)
    59  }
    60  
    61  func (m *MongoVersionSuite) TestString(c *gc.C) {
    62  	s := version1.String()
    63  	c.Assert(s, gc.Equals, "1.0")
    64  	s = version1d1.String()
    65  	c.Assert(s, gc.Equals, "1.1")
    66  	v := Version{Major: 1, Minor: 2, Patch: "something"}
    67  	s = v.String()
    68  	c.Assert(s, gc.Equals, "1.2.something")
    69  	v.StorageEngine = WiredTiger
    70  	s = v.String()
    71  	c.Assert(s, gc.Equals, "1.2.something/wiredTiger")
    72  }
    73  
    74  func (m *MongoPathSuite) TestMongodPath(c *gc.C) {
    75  	pathTests := map[Version]string{
    76  		Mongo26:   "/usr/lib/juju/mongo2.6/bin/mongod",
    77  		Mongo32wt: "/usr/lib/juju/mongo3.2/bin/mongod",
    78  	}
    79  	for v, exp := range pathTests {
    80  		p := JujuMongodPath(v)
    81  		c.Assert(p, gc.Equals, exp)
    82  	}
    83  }
    84  
    85  type fakeFileInfo struct {
    86  	isDir bool
    87  }
    88  
    89  func (f fakeFileInfo) Name() string       { return "" }
    90  func (f fakeFileInfo) Size() int64        { return 0 }
    91  func (f fakeFileInfo) Mode() os.FileMode  { return 0 }
    92  func (f fakeFileInfo) ModTime() time.Time { return time.Now() }
    93  func (f fakeFileInfo) IsDir() bool        { return f.isDir }
    94  func (f fakeFileInfo) Sys() interface{}   { return nil }
    95  
    96  func assertStatLook(c *gc.C, v Version, statErr, lookErr error, errReg, path, statCall, lookCall string) {
    97  	var statCalled string
    98  	stat := func(p string) (os.FileInfo, error) {
    99  		statCalled = p
   100  		return fakeFileInfo{}, statErr
   101  	}
   102  	var lookCalled string
   103  	look := func(p string) (string, error) {
   104  		lookCalled = p
   105  		if lookErr != nil {
   106  			return "", lookErr
   107  		}
   108  		return "/a/false/path", nil
   109  	}
   110  	p, err := mongoPath(v, stat, look)
   111  	if errReg == "" {
   112  		c.Assert(err, jc.ErrorIsNil)
   113  	} else {
   114  		c.Assert(err, gc.ErrorMatches, errReg)
   115  	}
   116  
   117  	c.Assert(p, gc.Equals, path)
   118  	c.Assert(statCalled, gc.Equals, statCall)
   119  	c.Assert(lookCalled, gc.Equals, lookCall)
   120  }
   121  
   122  func (m *MongoPathSuite) TestPath(c *gc.C) {
   123  	errMissing := errors.New("missing")
   124  	errLookupFailed := errors.New("failed lookup")
   125  	assertStatLook(c, Mongo24, nil, nil, "", JujuMongod24Path, JujuMongod24Path, "")
   126  
   127  	assertStatLook(c, Mongo24, errMissing, nil, "", "/a/false/path", JujuMongod24Path, "mongod")
   128  
   129  	assertStatLook(c, Mongo24, errMissing, errLookupFailed, "*failed lookup", "", JujuMongod24Path, "mongod")
   130  
   131  	mongo32Path := "/usr/lib/juju/mongo3.2/bin/mongod"
   132  	assertStatLook(c, Mongo32wt, nil, nil, "", mongo32Path, mongo32Path, "")
   133  
   134  	assertStatLook(c, Mongo32wt, errMissing, nil, "no suitable binary for \"3.2/wiredTiger\"", "", mongo32Path, "")
   135  }
   136  
   137  func (s *MongoPathSuite) TestMongoPath(c *gc.C) {
   138  	mongoInfo := []struct {
   139  		version Version
   140  		path    string
   141  	}{{
   142  		// Expected 2.4 wiredTiger version
   143  		version: Mongo24,
   144  		path:    JujuMongod24Path,
   145  	}, {
   146  		// Expected 3.6 wiredTiger version
   147  		version: Mongo36wt,
   148  		path:    MongodSystemPath,
   149  	}, {
   150  		// Version with Patch
   151  		version: Version{Major: 3, Minor: 6, Patch: "3"},
   152  		path:    MongodSystemPath,
   153  	}}
   154  	stat := func(string) (os.FileInfo, error) {
   155  		return nil, nil
   156  	}
   157  	lookPath := func(string) (string, error) {
   158  		return "", nil
   159  	}
   160  	for _, m := range mongoInfo {
   161  		actualPath, err := mongoPath(m.version, stat, lookPath)
   162  		c.Assert(err, jc.ErrorIsNil)
   163  		c.Assert(actualPath, gc.Equals, m.path)
   164  	}
   165  }