github.com/getgauge/gauge@v1.6.9/plugin/pluginInfo/pluginInfo_test.go (about)

     1  /*----------------------------------------------------------------
     2   *  Copyright (c) ThoughtWorks, Inc.
     3   *  Licensed under the Apache License, Version 2.0
     4   *  See LICENSE in the project root for license information.
     5   *----------------------------------------------------------------*/
     6  
     7  package pluginInfo
     8  
     9  import (
    10  	"fmt"
    11  	"path/filepath"
    12  	"testing"
    13  
    14  	"github.com/getgauge/gauge/version"
    15  	. "gopkg.in/check.v1"
    16  )
    17  
    18  func Test(t *testing.T) { TestingT(t) }
    19  
    20  type MySuite struct{}
    21  
    22  var _ = Suite(&MySuite{})
    23  
    24  func (s *MySuite) TestSortingOfPluginInfos(c *C) {
    25  	plugins := make(map[string]PluginInfo)
    26  	plugins["e"] = PluginInfo{Name: "e"}
    27  	plugins["b"] = PluginInfo{Name: "b"}
    28  	plugins["c"] = PluginInfo{Name: "c"}
    29  	plugins["d"] = PluginInfo{Name: "d"}
    30  	plugins["a"] = PluginInfo{Name: "a"}
    31  
    32  	actual := sortPlugins(plugins)
    33  
    34  	var expected []PluginInfo
    35  	expected = append(expected, PluginInfo{Name: "a"})
    36  	expected = append(expected, PluginInfo{Name: "b"})
    37  	expected = append(expected, PluginInfo{Name: "c"})
    38  	expected = append(expected, PluginInfo{Name: "d"})
    39  	expected = append(expected, PluginInfo{Name: "e"})
    40  
    41  	c.Assert(len(expected), Equals, len(plugins))
    42  	for i := range expected {
    43  		c.Assert(expected[i], Equals, actual[i])
    44  	}
    45  }
    46  
    47  func (s *MySuite) TestGetLatestPluginPath(c *C) {
    48  	path, _ := filepath.Abs(filepath.Join("_testdata", "java"))
    49  
    50  	latestVersion, err := GetLatestInstalledPlugin(path)
    51  
    52  	c.Assert(err, Equals, nil)
    53  	c.Assert(latestVersion.Version.String(), Equals, "1.2.0")
    54  	c.Assert(latestVersion.Name, Equals, "java")
    55  	c.Assert(latestVersion.Path, Equals, filepath.Join(path, "1.2.0"))
    56  }
    57  
    58  func (s *MySuite) TestGetLatestPluginPathIfNoPluginsFound(c *C) {
    59  	testData := "_testdata"
    60  	path, _ := filepath.Abs(testData)
    61  
    62  	_, err := GetLatestInstalledPlugin(path)
    63  
    64  	c.Assert(err.Error(), Equals, fmt.Sprintf("No valid versions of plugin %s found in %s", testData, path))
    65  }
    66  
    67  func (s *MySuite) TestGetLatestInstalledPlugin(c *C) {
    68  	path, _ := filepath.Abs(filepath.Join("_testdata", "java"))
    69  
    70  	latestPlugin, err := GetLatestInstalledPlugin(path)
    71  
    72  	c.Assert(err, Equals, nil)
    73  	c.Assert(latestPlugin.Path, Equals, filepath.Join(path, "1.2.0"))
    74  }
    75  
    76  func (s *MySuite) TestGetLatestInstalledPluginIfNoPluginsFound(c *C) {
    77  	testData := "_testdata"
    78  	path, _ := filepath.Abs(testData)
    79  
    80  	_, err := GetLatestInstalledPlugin(path)
    81  
    82  	c.Assert(err.Error(), Equals, fmt.Sprintf("No valid versions of plugin %s found in %s", testData, path))
    83  }
    84  
    85  func (s *MySuite) TestLatestVersionWithDifferentYearNightlies(c *C) {
    86  	v, _ := version.ParseVersion("0.2.2")
    87  
    88  	pluginInfo1 := PluginInfo{Version: v, Path: "0.2.2.nightly-2015-02-09"}
    89  	pluginInfo2 := PluginInfo{Version: v, Path: "0.2.2.nightly-2016-02-09"}
    90  	pluginInfo3 := PluginInfo{Version: v, Path: "0.2.2.nightly-2017-02-09"}
    91  	plugins := []PluginInfo{pluginInfo1, pluginInfo3, pluginInfo2}
    92  	latestBuild := getLatestOf(plugins, v)
    93  
    94  	c.Assert(latestBuild.Path, Equals, pluginInfo3.Path)
    95  	c.Assert(latestBuild.Version, Equals, v)
    96  }
    97  
    98  func (s *MySuite) TestLatestVersionWithDifferentMonthNightlies(c *C) {
    99  	v, _ := version.ParseVersion("0.2.2")
   100  
   101  	pluginInfo1 := PluginInfo{Version: v, Path: "0.2.2.nightly-2016-03-03"}
   102  	pluginInfo2 := PluginInfo{Version: v, Path: "0.2.2.nightly-2016-02-03"}
   103  	plugins := []PluginInfo{pluginInfo1, pluginInfo2}
   104  	latestBuild := getLatestOf(plugins, v)
   105  
   106  	c.Assert(latestBuild.Path, Equals, pluginInfo1.Path)
   107  	c.Assert(latestBuild.Version, Equals, v)
   108  }
   109  
   110  func (s *MySuite) TestLatestVersionWithDifferentDaysNightlies(c *C) {
   111  	v, _ := version.ParseVersion("0.2.2")
   112  
   113  	pluginInfo1 := PluginInfo{Version: v, Path: "0.2.2.nightly-2016-02-03"}
   114  	pluginInfo2 := PluginInfo{Version: v, Path: "0.2.2.nightly-2016-02-09"}
   115  	plugins := []PluginInfo{pluginInfo1, pluginInfo2}
   116  	latestBuild := getLatestOf(plugins, v)
   117  
   118  	c.Assert(latestBuild.Path, Equals, pluginInfo2.Path)
   119  	c.Assert(latestBuild.Version, Equals, v)
   120  }
   121  
   122  func (s *MySuite) TestLatestNightlyVersionWithDifferentStableVersion(c *C) {
   123  	v, _ := version.ParseVersion("0.2.2")
   124  
   125  	pluginInfo1 := PluginInfo{Version: v, Path: "0.2.2.nightly-2016-02-09"}
   126  	pluginInfo2 := PluginInfo{Version: v, Path: "0.2.3.nightly-2016-02-09"}
   127  	plugins := []PluginInfo{pluginInfo1, pluginInfo2}
   128  	latestBuild := getLatestOf(plugins, v)
   129  
   130  	c.Assert(latestBuild.Path, Equals, pluginInfo2.Path)
   131  	c.Assert(latestBuild.Version, Equals, v)
   132  }
   133  
   134  func (s *MySuite) TestLatestNightlyVersionWithDifferentDates(c *C) {
   135  	v, _ := version.ParseVersion("0.2.2")
   136  
   137  	pluginInfo1 := PluginInfo{Version: v, Path: "2.1.1.nightly-2016-05-02"}
   138  	pluginInfo2 := PluginInfo{Version: v, Path: "2.1.1.nightly-2016-04-27"}
   139  	plugins := []PluginInfo{pluginInfo1, pluginInfo2}
   140  	latestBuild := getLatestOf(plugins, v)
   141  
   142  	c.Assert(latestBuild.Path, Equals, pluginInfo1.Path)
   143  	c.Assert(latestBuild.Version, Equals, v)
   144  }
   145  
   146  func (s *MySuite) TestLatestVersionWithOnlyStableVersion(c *C) {
   147  	v, _ := version.ParseVersion("0.2.2")
   148  
   149  	pluginInfo1 := PluginInfo{Version: v, Path: "0.2.2"}
   150  	plugins := []PluginInfo{pluginInfo1}
   151  	latestBuild := getLatestOf(plugins, v)
   152  
   153  	c.Assert(latestBuild.Version, Equals, v)
   154  	c.Assert(latestBuild.Version, Equals, v)
   155  }
   156  
   157  func (s *MySuite) TestLatestVersionWithOnlyNightlyVersion(c *C) {
   158  	v, _ := version.ParseVersion("0.2.2")
   159  
   160  	pluginInfo1 := PluginInfo{Version: v, Path: "0.2.2.nightly-2016-02-09"}
   161  	plugins := []PluginInfo{pluginInfo1}
   162  	latestBuild := getLatestOf(plugins, v)
   163  
   164  	c.Assert(latestBuild.Version, Equals, v)
   165  	c.Assert(latestBuild.Version, Equals, v)
   166  }