github.com/joey-fossa/fossa-cli@v0.7.34-0.20190708193710-569f1e8679f0/buildtools/gradle/gradle_test.go (about)

     1  package gradle_test
     2  
     3  import (
     4  	"io/ioutil"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"github.com/fossas/fossa-cli/buildtools/gradle"
    10  	"github.com/fossas/fossa-cli/testing/helpers"
    11  )
    12  
    13  /*
    14  	├─┬ dep:one:1.0.0
    15  	| └─┬ dep:three:3.0.0
    16    	|   └── dep:four:4.0.0
    17  	└─┬ dep:two:2.0.0
    18  	  ├─┬ dep:three:3.0.0
    19  	  │ └── dep:four:4.0.0
    20  	  └── dep:five:5.0.0
    21  */
    22  
    23  func TestAllDependencies(t *testing.T) {
    24  	dos := "testdata/complete-dos"
    25  	unix := "testdata/complete-unix"
    26  	for _, file := range []string{dos, unix} {
    27  		data, err := ioutil.ReadFile(file)
    28  		assert.NoError(t, err)
    29  		if file == dos {
    30  			helpers.AssertDosFile(t, data)
    31  		} else if file == unix {
    32  			helpers.AssertUnixFile(t, data)
    33  		}
    34  
    35  		g := MockGradle(t, file)
    36  		graph, err := gradle.Dependencies("argument-not-needed-for-mock", g)
    37  		assert.NoError(t, err)
    38  
    39  		direct := graph["test"].Direct
    40  		assert.Equal(t, 3, len(direct))
    41  		helpers.AssertPackageImport(t, direct, "core", "")
    42  		helpers.AssertPackageImport(t, direct, "dep:one", "1.0")
    43  		helpers.AssertPackageImport(t, direct, "dep:two", "2.0")
    44  
    45  		transitive := graph["test"].Transitive
    46  		assert.Equal(t, 6, len(transitive))
    47  
    48  		packageProject := helpers.PackageInTransitiveGraph(transitive, "core", "")
    49  		assert.NotEmpty(t, packageProject)
    50  		assert.Equal(t, 0, len(packageProject.Imports))
    51  
    52  		packageOne := helpers.PackageInTransitiveGraph(transitive, "dep:one", "1.0")
    53  		assert.NotEmpty(t, packageOne)
    54  		assert.Equal(t, 1, len(packageOne.Imports))
    55  		helpers.AssertPackageImport(t, packageOne.Imports, "dep:three", "3.0")
    56  
    57  		packageTwo := helpers.PackageInTransitiveGraph(transitive, "dep:two", "2.0")
    58  		assert.NotEmpty(t, packageTwo)
    59  		assert.Equal(t, 2, len(packageTwo.Imports))
    60  		helpers.AssertPackageImport(t, packageTwo.Imports, "dep:three", "3.0")
    61  		helpers.AssertPackageImport(t, packageTwo.Imports, "dep:five", "5.0")
    62  
    63  		packageThree := helpers.PackageInTransitiveGraph(transitive, "dep:three", "3.0")
    64  		assert.NotEmpty(t, packageThree)
    65  		assert.Equal(t, 1, len(packageThree.Imports))
    66  		helpers.AssertPackageImport(t, packageThree.Imports, "dep:four", "4.0")
    67  
    68  		packageFour := helpers.PackageInTransitiveGraph(transitive, "dep:four", "4.0")
    69  		assert.NotEmpty(t, packageFour)
    70  		assert.Equal(t, 0, len(packageFour.Imports))
    71  
    72  		packageFive := helpers.PackageInTransitiveGraph(transitive, "dep:five", "5.0")
    73  		assert.NotEmpty(t, packageFive)
    74  		assert.Equal(t, 0, len(packageFive.Imports))
    75  	}
    76  }
    77  
    78  func TestParseDependencies(t *testing.T) {
    79  	data, err := ioutil.ReadFile("testdata/complex.txt")
    80  	assert.NoError(t, err)
    81  	imports, deps, err := gradle.ParseDependencies(string(data))
    82  	assert.NoError(t, err)
    83  
    84  	// A simple dependency.
    85  	expectImport1 := gradle.Dependency{
    86  		Name:             "io.springfox:springfox-swagger2",
    87  		RequestedVersion: "2.9.2",
    88  		ResolvedVersion:  "2.9.2",
    89  	}
    90  	assert.Contains(t, imports, expectImport1)
    91  
    92  	// Without a requested version.
    93  	expectImport2 := gradle.Dependency{
    94  		Name:             "org.springframework.boot:spring-boot-starter",
    95  		RequestedVersion: "",
    96  		ResolvedVersion:  "2.1.0.RELEASE",
    97  	}
    98  	assert.Contains(t, imports, expectImport2)
    99  
   100  	// With a requested version and resolved version.
   101  	expectDep1 := gradle.Dependency{
   102  		Name:             "com.fasterxml:classmate",
   103  		RequestedVersion: "1.3.4",
   104  		ResolvedVersion:  "1.4.0",
   105  	}
   106  	assert.Contains(t, deps, expectDep1)
   107  
   108  	// With a requested version and resolved version.
   109  	expectDep2 := gradle.Dependency{
   110  		Name:             "org.slf4j:slf4j-api",
   111  		RequestedVersion: "1.6.4",
   112  		ResolvedVersion:  "1.7.25",
   113  	}
   114  	assert.Contains(t, deps, expectDep2)
   115  
   116  	// A project.
   117  	expectProject1 := gradle.Dependency{
   118  		Name:             "typical-project-name",
   119  		RequestedVersion: "",
   120  		ResolvedVersion:  "",
   121  		IsProject:        true,
   122  	}
   123  	assert.Contains(t, deps, expectProject1)
   124  
   125  	// A project.
   126  	expectProject2 := gradle.Dependency{
   127  		Name:             "no-colons-in-project-name",
   128  		RequestedVersion: "",
   129  		ResolvedVersion:  "",
   130  		IsProject:        true,
   131  	}
   132  	assert.Contains(t, deps, expectProject2)
   133  }
   134  
   135  func TestShellCommand_DependencyTasks(t *testing.T) {
   136  	// We should be able to identify the projects by running "gradle tasks" even if a project has the
   137  	// word "dependencies" in it.
   138  	cmd := MockGradle(t, "testdata/tasks-output.txt")
   139  	projects, err := cmd.DependencyTasks()
   140  	assert.NoError(t, err)
   141  	assert.Equal(t, []string{"dependencies-proj"}, projects)
   142  }
   143  
   144  func MockGradle(t *testing.T, file string) gradle.ShellCommand {
   145  	fileContents, err := ioutil.ReadFile(file)
   146  	assert.NoError(t, err)
   147  	return gradle.ShellCommand{
   148  		Cmd: func(string, string, int, ...string) (string, error) {
   149  			return string(fileContents), nil
   150  		},
   151  	}
   152  }