github.com/jenkins-x/jx/v2@v2.1.155/pkg/kube/jenkins_test.go (about)

     1  // +build unit
     2  
     3  package kube_test
     4  
     5  import (
     6  	"testing"
     7  
     8  	"github.com/beevik/etree"
     9  	"github.com/jenkins-x/jx/v2/pkg/auth"
    10  	"github.com/jenkins-x/jx/v2/pkg/gits"
    11  	"github.com/jenkins-x/jx/v2/pkg/kube"
    12  	"github.com/jenkins-x/jx/v2/pkg/tests"
    13  	"github.com/stretchr/testify/assert"
    14  	corev1 "k8s.io/api/core/v1"
    15  )
    16  
    17  func TestAddGiteaServers(t *testing.T) {
    18  	t.Parallel()
    19  	cm := &corev1.ConfigMap{
    20  		Data: map[string]string{},
    21  	}
    22  
    23  	expectedGitURL := "https://my.gitea.com"
    24  	expectedGitName := "mygitea"
    25  	expectedCredentials := "my-credential-name"
    26  	server := &auth.AuthServer{
    27  		Kind: gits.KindGitea,
    28  		Name: expectedGitName,
    29  		URL:  expectedGitURL,
    30  	}
    31  	userAuth := &auth.UserAuth{
    32  		Username: "dummy",
    33  	}
    34  
    35  	updated, err := kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
    36  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
    37  	assert.True(t, updated, "Should have updated the ConfigMap for server %s", expectedGitURL)
    38  
    39  	for k, v := range cm.Data {
    40  		tests.Debugf("Updated the ConfigMap: %s = %s\n", k, v)
    41  	}
    42  
    43  	doc, _, err := kube.ParseXml(cm.Data[kube.GiteaConfigMapKey])
    44  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
    45  	assertElementValues(t, doc, "//serverUrl", expectedGitURL)
    46  
    47  	updated, err = kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
    48  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
    49  	assert.False(t, updated, "Should not have updated the ConfigMap for server %s", expectedGitURL)
    50  
    51  	doc, _, err = kube.ParseXml(cm.Data[kube.GiteaConfigMapKey])
    52  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
    53  	assertElementValues(t, doc, "//serverUrl", expectedGitURL)
    54  
    55  	// lets add an extra service to an existing one
    56  	cm.Data[kube.GiteaConfigMapKey] = `<?xml version='1.1' encoding='UTF-8'?>
    57  <org.jenkinsci.plugin.gitea.servers.GiteaServers plugin="gitea@1.0.5">
    58    <servers>
    59      <org.jenkinsci.plugin.gitea.servers.GiteaServer>
    60        <displayName>gitea</displayName>
    61        <serverUrl>http://gitea.changeme.com</serverUrl>
    62        <manageHooks>true</manageHooks>
    63        <credentialsId>jenkins-x-gitea</credentialsId>
    64      </org.jenkinsci.plugin.gitea.servers.GiteaServer>
    65    </servers>
    66  </org.jenkinsci.plugin.gitea.servers.GiteaServers>
    67  `
    68  	updated, err = kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
    69  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
    70  	assert.True(t, updated, "Should have updated the ConfigMap for server %s", expectedGitURL)
    71  
    72  	doc, _, err = kube.ParseXml(cm.Data[kube.GiteaConfigMapKey])
    73  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
    74  	assertElementValues(t, doc, "//serverUrl", "http://gitea.changeme.com", expectedGitURL)
    75  
    76  	// lets modify an existing credentials value
    77  	// lets add an extra service to an existing one
    78  	cm.Data[kube.GiteaConfigMapKey] = `<?xml version='1.1' encoding='UTF-8'?>
    79  <org.jenkinsci.plugin.gitea.servers.GiteaServers plugin="gitea@1.0.5">
    80    <servers>
    81      <org.jenkinsci.plugin.gitea.servers.GiteaServer>
    82        <displayName>gitea</displayName>
    83        <serverUrl>` + expectedGitURL + `</serverUrl>
    84        <manageHooks>true</manageHooks>
    85        <credentialsId>jenkins-x-gitea</credentialsId>
    86      </org.jenkinsci.plugin.gitea.servers.GiteaServer>
    87    </servers>
    88  </org.jenkinsci.plugin.gitea.servers.GiteaServers>
    89  `
    90  
    91  	updated, err = kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
    92  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
    93  	assert.True(t, updated, "Should have updated the ConfigMap for server %s", expectedGitURL)
    94  
    95  	doc, _, err = kube.ParseXml(cm.Data[kube.GiteaConfigMapKey])
    96  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
    97  	assertElementValues(t, doc, "//serverUrl", expectedGitURL)
    98  	assertElementValues(t, doc, "//credentialsId", expectedCredentials)
    99  }
   100  
   101  func TestAddGitHuvServers(t *testing.T) {
   102  	t.Parallel()
   103  	key := kube.GithubConfigMapKey
   104  	kind := gits.KindGitHub
   105  
   106  	cm := &corev1.ConfigMap{
   107  		Data: map[string]string{},
   108  	}
   109  
   110  	expectedGitHostURL := "https://github.bees.com"
   111  	expectedGitURL := expectedGitHostURL + "/api/v3/"
   112  	expectedGitName := "GHE"
   113  	expectedCredentials := "my-credential-name"
   114  	server := &auth.AuthServer{
   115  		Kind: kind,
   116  		Name: expectedGitName,
   117  		URL:  expectedGitHostURL,
   118  	}
   119  	userAuth := &auth.UserAuth{
   120  		Username: "dummy",
   121  	}
   122  
   123  	updated, err := kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
   124  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
   125  	assert.True(t, updated, "Should have updated the ConfigMap for server %s", expectedGitURL)
   126  
   127  	for k, v := range cm.Data {
   128  		tests.Debugf("Updated the ConfigMap: %s = %s\n", k, v)
   129  	}
   130  
   131  	doc, _, err := kube.ParseXml(cm.Data[key])
   132  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
   133  	assertElementValues(t, doc, "//apiUri", expectedGitURL)
   134  
   135  	updated, err = kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
   136  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
   137  	assert.False(t, updated, "Should not have updated the ConfigMap for server %s", expectedGitURL)
   138  
   139  	doc, _, err = kube.ParseXml(cm.Data[key])
   140  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
   141  	assertElementValues(t, doc, "//apiUri", expectedGitURL)
   142  }
   143  
   144  func TestAddBitBucketServerServers(t *testing.T) {
   145  	t.Parallel()
   146  	kind := gits.KindBitBucketServer
   147  	key := kube.BitbucketConfigMapKey
   148  
   149  	cm := &corev1.ConfigMap{
   150  		Data: map[string]string{},
   151  	}
   152  
   153  	expectedGitURL := "https://my.bitbucket.com"
   154  	expectedGitName := "mybitbucket"
   155  	expectedCredentials := "my-credential-name"
   156  	server := &auth.AuthServer{
   157  		Kind: kind,
   158  		Name: expectedGitName,
   159  		URL:  expectedGitURL,
   160  	}
   161  	userAuth := &auth.UserAuth{
   162  		Username: "dummy",
   163  	}
   164  
   165  	updated, err := kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
   166  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
   167  	assert.True(t, updated, "Should have updated the ConfigMap for server %s", expectedGitURL)
   168  
   169  	for k, v := range cm.Data {
   170  		tests.Debugf("Updated the ConfigMap: %s = %s\n", k, v)
   171  	}
   172  
   173  	doc, _, err := kube.ParseXml(cm.Data[key])
   174  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
   175  	assertElementValues(t, doc, "//serverUrl", expectedGitURL)
   176  
   177  	updated, err = kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
   178  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
   179  	assert.False(t, updated, "Should not have updated the ConfigMap for server %s", expectedGitURL)
   180  
   181  	doc, _, err = kube.ParseXml(cm.Data[key])
   182  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
   183  	assertElementValues(t, doc, "//serverUrl", expectedGitURL)
   184  }
   185  
   186  func TestAddBitBucketCloudServers(t *testing.T) {
   187  	t.Parallel()
   188  	kind := gits.KindBitBucketCloud
   189  	key := kube.BitbucketConfigMapKey
   190  
   191  	cm := &corev1.ConfigMap{
   192  		Data: map[string]string{},
   193  	}
   194  
   195  	expectedGitURL := gits.BitbucketCloudURL
   196  	expectedGitName := "mybitbucket"
   197  	expectedCredentials := "my-credential-name"
   198  	server := &auth.AuthServer{
   199  		Kind: kind,
   200  		Name: expectedGitName,
   201  		URL:  expectedGitURL,
   202  	}
   203  	userAuth := &auth.UserAuth{
   204  		Username: "dummy",
   205  	}
   206  
   207  	updated, err := kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
   208  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
   209  	assert.True(t, updated, "Should have updated the ConfigMap for server %s", expectedGitURL)
   210  
   211  	for k, v := range cm.Data {
   212  		tests.Debugf("Updated the ConfigMap: %s = %s\n", k, v)
   213  	}
   214  
   215  	doc, _, err := kube.ParseXml(cm.Data[key])
   216  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
   217  	assertElementValues(t, doc, "//credentialsId", expectedCredentials)
   218  
   219  	updated, err = kube.UpdateJenkinsGitServers(cm, server, userAuth, expectedCredentials)
   220  	assert.Nil(t, err, "Failed to update the ConfigMap for server %s", expectedGitURL)
   221  	assert.False(t, updated, "Should not have updated the ConfigMap for server %s", expectedGitURL)
   222  
   223  	doc, _, err = kube.ParseXml(cm.Data[key])
   224  	assert.Nil(t, err, "Failed to parse resulting xml for server %s", expectedGitURL)
   225  	assertElementValues(t, doc, "//credentialsId", expectedCredentials)
   226  }
   227  
   228  func assertElementValues(t *testing.T, doc *etree.Document, path string, expectedValues ...string) {
   229  	elements := doc.FindElements(path)
   230  	actuals := []string{}
   231  	for _, e := range elements {
   232  		actuals = append(actuals, e.Text())
   233  	}
   234  	assert.EqualValues(t, expectedValues, actuals, "Invalid values for path %s", path)
   235  }