diff --git a/clients/gitlab/client.go b/clients/gitlab/client.go
index 45e7cd945e4993ac43b9e320edd275e8cdf1dd72..7b39504e56c0f81068f3749092fa027712f0f074 100644
--- a/clients/gitlab/client.go
+++ b/clients/gitlab/client.go
@@ -599,8 +599,8 @@ func (r Client) GetProjects(search *string) ([]*gogitlab.Project, error) {
 		ListOptions: listOptions,
 		OrderBy:     &orderBy,
 	}
-	// if search defined add it to opts
 
+	// if search defined add it to opts
 	if search != nil {
 		opts.Search = search
 	}
@@ -629,7 +629,7 @@ func (r Client) GetProjects(search *string) ([]*gogitlab.Project, error) {
 }
 
 // AddProject -
-func (r Client) AddProject(createProjectOptions gogitlab.CreateProjectOptions, groupID int) (*gogitlab.Project, int, error) {
+func (r Client) AddProject(createProjectOptions gogitlab.CreateProjectOptions) (*gogitlab.Project, int, error) {
 	logPrefix := "AddProject"
 	// force visibility to private
 	var visibility = gogitlab.PrivateVisibility
@@ -638,7 +638,7 @@ func (r Client) AddProject(createProjectOptions gogitlab.CreateProjectOptions, g
 		Name:        createProjectOptions.Name,
 		Path:        createProjectOptions.Path,
 		Description: createProjectOptions.Description,
-		NamespaceID: &groupID,
+		NamespaceID: createProjectOptions.NamespaceID,
 		// hard coded values
 		Visibility: &visibility,
 	}
diff --git a/clients/gitlab/client_test.go b/clients/gitlab/client_test.go
index c37374f6bd0e9630b58a31f09b84b6d736928e13..9073ddc5ea7a86b1096d12281566431a2771e246 100644
--- a/clients/gitlab/client_test.go
+++ b/clients/gitlab/client_test.go
@@ -937,9 +937,10 @@ func TestClient_AddProject(t *testing.T) {
 	defer httpmock.DeactivateAndReset()
 
 	testProjectID := 1
+	testGroupID := 12
 	testProjectName := "testProjectName"
 	testProject := gogitlab.Project{ID: testProjectID, Name: testProjectName}
-	createTestProjetOptions := gogitlab.CreateProjectOptions{Name: &testProjectName}
+	createTestProjetOptions := gogitlab.CreateProjectOptions{Name: &testProjectName, NamespaceID: &testGroupID}
 
 	httpmock.RegisterResponder("POST",
 		"https://test/api/v4/projects",
@@ -959,7 +960,6 @@ func TestClient_AddProject(t *testing.T) {
 	}
 	type args struct {
 		createProjectOptions *gogitlab.CreateProjectOptions
-		groupID              int
 	}
 	tests := []struct {
 		name    string
@@ -985,7 +985,7 @@ func TestClient_AddProject(t *testing.T) {
 				token:  tt.fields.token,
 				apiURL: tt.fields.apiURL,
 			}
-			got, got1, err := r.AddProject(*tt.args.createProjectOptions, tt.args.groupID)
+			got, got1, err := r.AddProject(*tt.args.createProjectOptions)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Client.AddProject() error = %v, wantErr %v", err, tt.wantErr)
 				return
diff --git a/integration-tests/gitlab/api/gitlab_api_adhoc_test.go b/integration-tests/gitlab/api/gitlab_api_adhoc_test.go
index b21e399c74ead84d0d5a8cb45083733477391648..4e50afd3e36d9daca1f9dfb9e1c7297156c77242 100644
--- a/integration-tests/gitlab/api/gitlab_api_adhoc_test.go
+++ b/integration-tests/gitlab/api/gitlab_api_adhoc_test.go
@@ -3,15 +3,13 @@
 package integration
 
 import (
-    "testing"
 	"errors"
 	"os"
+	"testing"
 	gitlab "valkyrie.dso.mil/valkyrie-api/clients/gitlab"
-
-	gogitlab "github.com/xanzy/go-gitlab"
 )
 
-// getClient_AdHoc - 
+// getClient_AdHoc -
 func getClient_AdHoc() (gitlab.Client, error) {
 	gitlabAPIURL, ok := os.LookupEnv("GITLAB_API_URL")
 	if !ok {
@@ -21,7 +19,7 @@ func getClient_AdHoc() (gitlab.Client, error) {
 	if !ok {
 		return gitlab.Client{}, errors.New("env variable GITLAB_API_TOKEN undefinded")
 	}
-	var client = gitlab.NewClient(gitlabAPIURL, gitlabAPIToken,nil)
+	var client = gitlab.NewClient(gitlabAPIURL, gitlabAPIToken, nil)
 	return client, nil
 }
 func TestClient_AdHoc_getUsers_All(t *testing.T) {
@@ -37,7 +35,7 @@ func TestClient_AdHoc_getUsers_All(t *testing.T) {
 			return
 		}
 		t.Logf("GetUsers %d", len(got))
-		for x:=0;x<len(got);x++ {
+		for x := 0; x < len(got); x++ {
 			t.Logf("user: [%d, %s, %s, %s]", got[x].ID, got[x].Name, got[x].Username, got[x].WebURL)
 		}
 	})
@@ -56,7 +54,7 @@ func TestClient_AdHoc_getUsers_Search(t *testing.T) {
 			return
 		}
 		t.Logf("GetUsers %d", len(got))
-		for x:=0;x<len(got);x++ {
+		for x := 0; x < len(got); x++ {
 			t.Logf("user: [%d, %s, %s, %s]", got[x].ID, got[x].Name, got[x].Username, got[x].WebURL)
 		}
 	})
@@ -75,29 +73,12 @@ func TestClient_AdHoc_getUsers_None(t *testing.T) {
 			return
 		}
 		t.Logf("GetUsers %d", len(got))
-		for x:=0;x<len(got);x++ {
+		for x := 0; x < len(got); x++ {
 			t.Logf("user: [%d, %s, %s, %s]", got[x].ID, got[x].Name, got[x].Username, got[x].WebURL)
 		}
 	})
 }
 
-func TestClient_AdHoc_deleteUser_None(t *testing.T) {
-	t.Run("test", func(t *testing.T) {
-		c, err := getClient_AdHoc()
-		if err != nil {
-			t.Errorf("Client.GetUsers() error = %v", err)
-			return
-		}
-		username := "notfound"
-		statusCode, err := c.DeleteUserByUsername(username)
-		if err != nil {
-			t.Errorf("Client.DeleteUser() error = %v", err)
-			return
-		}
-		t.Logf("DeleteUser success: %d", statusCode)
-	})
-}
-
 func TestClient_AdHoc_getGroups_All(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
 		c, err := getClient_AdHoc()
@@ -105,14 +86,14 @@ func TestClient_AdHoc_getGroups_All(t *testing.T) {
 			t.Errorf("Client.getClient() error = %v", err)
 			return
 		}
-	
+
 		got, err := c.GetGroups(nil)
 		if err != nil {
 			t.Errorf("Client.GetGroups() error = %v", err)
 			return
 		}
 		t.Logf("GetGroups %d", len(got))
-		for x:=0;x<len(got);x++ {
+		for x := 0; x < len(got); x++ {
 			t.Logf("group: [%d, %s, %s, %s]", got[x].ID, got[x].FullName, got[x].FullPath, got[x].WebURL)
 		}
 	})
@@ -124,78 +105,19 @@ func TestClient_AdHoc_getGroups_Search(t *testing.T) {
 			t.Errorf("Client.getClient() error = %v", err)
 			return
 		}
-		s := string("adam")
+		s := string("test")
 		got, err := c.GetGroups(&s)
 		if err != nil {
 			t.Errorf("Client.GetGroups() error = %v", err)
 			return
 		}
 		t.Logf("GetGroups %d", len(got))
-		for x:=0;x<len(got);x++ {
+		for x := 0; x < len(got); x++ {
 			t.Logf("group: [%d, %s, %s, %s]", got[x].ID, got[x].FullName, got[x].FullPath, got[x].WebURL)
 		}
 	})
 }
 
-func TestClient_AdHoc_addGroups_SubGroup(t *testing.T) {
-	t.Run("test", func(t *testing.T) {
-		c, err := getClient_AdHoc()
-		if err != nil {
-			t.Errorf("Client.getClient() error = %v", err)
-			return
-		}
-		s := string("adam-top-group")
-		groupList, err := c.GetGroups(&s)
-		if err != nil {
-			t.Errorf("Client.GetGroups() error = %v", err)
-			return
-		}
-
-		if len(groupList) == 0 {
-		var statusCode int
-
-		groupName := "adam root"
-		groupPath := "adam-root"
-		groupObj := gogitlab.Group{Name: groupName, Path: groupPath}
-		group, statusCode, err := c.AddGroup(&groupObj, nil)
-		if err != nil {
-			t.Errorf("AddGroup error = %v", err)
-			return
-		}
-		t.Logf("AddGroup: %s %d", group.FullPath, statusCode)
-
-		groupName = "adam subgroup"
-		groupPath = "adam-subgroup"
-		groupObj = gogitlab.Group{Name: groupName, Path: groupPath}
-		subgroup, statusCode, err := c.AddGroup(&groupObj, &group.ID)
-		if err != nil {
-			t.Errorf("AddGroup error = %v", err)
-			return
-		}
-		t.Logf("AddGroup: %s %d", subgroup2.FullPath, statusCode)
-
-		for i := 1; i <= 125; i++ {
-			projectName := "test project " + fmt.Sprintf("%d", i)
-
-			projectObj := gogitlab.CreateProjectOptions{Name: &projectName}
-			got, statusCode, err := c.AddProject(projectObj, group.ID)
-
-			if err != nil {
-				t.Errorf("Client.AddProject() error = %v %d", err, statusCode)
-			} else {
-				t.Logf("AddProject: [%s, %s, %d]", got.NameWithNamespace, got.HTTPURLToRepo, statusCode)
-			}
-		}
-		for i := 1; i <= 125; i++ {
-			projectName := "test project " + fmt.Sprintf("%d", i)
-
-			projectObj := gogitlab.CreateProjectOptions{Name: &projectName}
-			got, statusCode, err := c.AddProject(projectObj, subgroup1.ID)
-
-	})
-}
-
-
 func TestClient_AdHoc_getProjects_ALL(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
 		c, err := getClient_AdHoc()
@@ -209,7 +131,7 @@ func TestClient_AdHoc_getProjects_ALL(t *testing.T) {
 			return
 		}
 		t.Logf("GetProjects %d", len(got))
-		for x:=0;x<len(got);x++ {
+		for x := 0; x < len(got); x++ {
 			t.Logf("project: [%d, %s, %s, %s]", got[x].ID, got[x].Name, got[x].PathWithNamespace, got[x].HTTPURLToRepo)
 		}
 	})
diff --git a/integration-tests/gitlab/api/gitlab_api_groups_test.go b/integration-tests/gitlab/api/gitlab_api_groups_test.go
index 229ca5be10057d869a46e75838bae677da33eb50..0dc5d44d6d8647c1a647b33fe2435ae0bbfafe14 100644
--- a/integration-tests/gitlab/api/gitlab_api_groups_test.go
+++ b/integration-tests/gitlab/api/gitlab_api_groups_test.go
@@ -5,6 +5,7 @@ package integration
 import (
 	"errors"
 	"fmt"
+	"net/http"
 	"os"
 	"testing"
 
@@ -14,8 +15,10 @@ import (
 
 const groupsTestItemCount = 65
 
-// getClient_Groups -
-func getClient_Groups() (gitlab.Client, error) {
+var integrationRootGroupID = 0
+
+// getClientGroups -
+func getClientGroups() (gitlab.Client, error) {
 	gitlabAPIURL, ok := os.LookupEnv("GITLAB_API_URL")
 	if !ok {
 		return gitlab.Client{}, errors.New("env variable GITLAB_API_URL undefinded")
@@ -28,10 +31,9 @@ func getClient_Groups() (gitlab.Client, error) {
 	return client, nil
 }
 
-
 func TestClient_GetGroups(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Groups()
+		c, err := getClientGroups()
 		if err != nil {
 			t.Errorf("Client.getClient() error = %v", err)
 			return
@@ -45,9 +47,47 @@ func TestClient_GetGroups(t *testing.T) {
 	})
 }
 
+func TestClient_AddRootGroup(t *testing.T) {
+	t.Run("test", func(t *testing.T) {
+		c, err := getClientGroups()
+		if err != nil {
+			t.Errorf("Client.getClient() error = %v", err)
+			return
+		}
+
+		path := "integration-root-group"
+		name := "integration root group"
+		description := "Integration Test Root Level Group"
+
+		group, statusCode, err := c.GetGroupByFullPath(&path)
+		if err != nil {
+			// dont fail if group already exists
+			t.Errorf("Client.GetGroupByFullPath() error = %v %d", err, statusCode)
+			return
+		}
+
+		if statusCode == http.StatusFound {
+			integrationRootGroupID = group.ID
+			t.Logf("AddGroup %s %s %s %s %d", group.Name, group.Path, group.FullPath, group.WebURL, statusCode)
+		} else {
+			groupOpts := gogitlab.CreateGroupOptions{Name: &name, Path: &path, Description: &description}
+			got, statusCode, err := c.AddGroup(groupOpts)
+
+			if err != nil {
+				// dont fail if group already exists
+				t.Logf("Client.AddGroup() error = %v %d", err, statusCode)
+			} else {
+				integrationRootGroupID = got.ID
+				t.Logf("AddGroup %s %s %s %s %d", got.Name, got.Path, got.FullPath, got.WebURL, statusCode)
+			}
+		}
+	})
+}
+
+// add groups under the integration test root level group
 func TestClient_AddGroups(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Groups()
+		c, err := getClientGroups()
 		if err != nil {
 			t.Errorf("Client.getClient() error = %v", err)
 			return
@@ -56,9 +96,14 @@ func TestClient_AddGroups(t *testing.T) {
 		for i := 1; i <= groupsTestItemCount; i++ {
 			path := "test-group-" + fmt.Sprintf("%d", i)
 			name := "test group " + fmt.Sprintf("%d", i)
+			description := "My fancy test group " + fmt.Sprintf("%d", i)
 
-			groupObj := gogitlab.Group{Name: name, Path: path}
-			got, statusCode, err := c.AddGroup(&groupObj, nil)
+			groupOpts := gogitlab.CreateGroupOptions{Name: &name,
+				Path:        &path,
+				Description: &description,
+				ParentID:    &integrationRootGroupID,
+			}
+			got, statusCode, err := c.AddGroup(groupOpts)
 
 			if err != nil {
 				t.Errorf("Client.AddGroup() error = %v %d", err, statusCode)
@@ -70,9 +115,88 @@ func TestClient_AddGroups(t *testing.T) {
 	})
 }
 
+func TestClient_UpdateGroup(t *testing.T) {
+	t.Run("test", func(t *testing.T) {
+		c, err := getClientGroups()
+		if err != nil {
+			t.Errorf("Client.GetUsers() error = %v", err)
+			return
+		}
+
+		// create a group to contain test objects
+		groupPath1 := "test-update-group-01"
+		groupName1 := "test update group 01"
+		groupDescription1 := "my fancy root level group 01"
+		groupOpts1 := gogitlab.CreateGroupOptions{
+			Name:        &groupName1,
+			Path:        &groupPath1,
+			Description: &groupDescription1,
+			ParentID:    &integrationRootGroupID,
+		}
+		group1, statusCode, err := c.AddGroup(groupOpts1)
+		if err != nil {
+			t.Errorf("Client.AddGroup() error = %v", err)
+			return
+		}
+		t.Logf("    created group %s status code %d", group1.Name, statusCode)
+
+		// create a subgroup level group
+		groupPath2 := "test-update-group-02"
+		groupName2 := "test update group 02"
+		groupDescription2 := "my fancy root level group 02"
+		groupOpts2 := gogitlab.CreateGroupOptions{
+			Name:        &groupName2,
+			Path:        &groupPath2,
+			Description: &groupDescription2,
+			ParentID:    &group1.ID,
+		}
+		group2, statusCode, err := c.AddGroup(groupOpts2)
+		if err != nil {
+			t.Errorf("Client.AddGroup() error = %v", err)
+			return
+		}
+		t.Logf("    created group %s status code %d", group2.Name, statusCode)
+
+		findGroup, statusCode, err := c.GetGroupByFullPath(&group2.FullPath)
+		if err != nil {
+			t.Errorf("Client.GetGroupByFullPath() error = %v", err)
+			return
+		}
+		t.Logf("GetGroupByFullPath: %s %d", findGroup.FullPath, statusCode)
+
+		// update user
+		testDescription := "Updated Description"
+		updateGroupOptions := gogitlab.UpdateGroupOptions{Description: &testDescription}
+		updatedGroup, statusCode, err := c.UpdateGroup(findGroup.ID, &updateGroupOptions)
+		if err != nil {
+			t.Errorf("Client.GetGroupByFullPath() error = %v", err)
+			return
+		}
+		t.Logf("UpdateGroup: %s %d", updatedGroup.Description, statusCode)
+
+		findGroup, statusCode, err = c.GetGroupByFullPath(&findGroup.FullPath)
+		if err != nil {
+			t.Errorf("Client.GetGroupByFullPath() error = %v", err)
+			return
+		}
+		t.Logf("GetGroupByFullPath: %s %d", findGroup.FullPath, statusCode)
+
+		if findGroup.Description != testDescription {
+			t.Errorf("TestClient_UpdateGroup expected %s got %s", testDescription, findGroup.Description)
+		} else {
+			t.Logf("TestClient_UpdateUser success. updated Description: %s for Group: %s", findGroup.Description, findGroup.Name)
+		}
+
+		// cleanup
+		statusCode, _ = c.DeleteGroup(group1.ID, 0, 0)
+		t.Logf("DeleteGroup no wait statusCode: %d", statusCode)
+
+	})
+}
+
 func TestClient_GetGroups2(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Groups()
+		c, err := getClientGroups()
 		if err != nil {
 			t.Errorf("Client.getClient() error = %v", err)
 			return
@@ -88,7 +212,7 @@ func TestClient_GetGroups2(t *testing.T) {
 
 func TestClient_deleteGroups(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Groups()
+		c, err := getClientGroups()
 		if err != nil {
 			t.Errorf("Client.getClient() error = %v", err)
 			return
@@ -96,6 +220,10 @@ func TestClient_deleteGroups(t *testing.T) {
 
 		search := "test-group"
 		groupList, err := c.GetGroups(&search)
+		if err != nil {
+			t.Errorf("Client.GetGroups() error = %v", err)
+			return
+		}
 
 		for x := 0; x < len(groupList); x++ {
 			group := groupList[x]
diff --git a/integration-tests/gitlab/api/gitlab_api_projects_test.go b/integration-tests/gitlab/api/gitlab_api_projects_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b4c4d3aeabbeff251b420256cc0cccf2f989a10f
--- /dev/null
+++ b/integration-tests/gitlab/api/gitlab_api_projects_test.go
@@ -0,0 +1,211 @@
+// +build integration
+
+package integration
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"testing"
+
+	gogitlab "github.com/xanzy/go-gitlab"
+	gitlab "valkyrie.dso.mil/valkyrie-api/clients/gitlab"
+)
+
+const projectsTestItemCount = 65
+const testProjectsPrefix = "IntTestProject"
+
+var integrationRootGroupID = 0
+
+// getClientProjects -
+func getClientProjects() (gitlab.Client, error) {
+	gitlabAPIURL, ok := os.LookupEnv("GITLAB_API_URL")
+	if !ok {
+		return gitlab.Client{}, errors.New("env variable GITLAB_API_URL undefinded")
+	}
+	gitlabAPIToken, ok := os.LookupEnv("GITLAB_API_TOKEN")
+	if !ok {
+		return gitlab.Client{}, errors.New("env variable GITLAB_API_TOKEN undefinded")
+	}
+	var client = gitlab.NewClient(gitlabAPIURL, gitlabAPIToken, nil)
+	return client, nil
+}
+
+func TestClient_GetProjects(t *testing.T) {
+	t.Run("test", func(t *testing.T) {
+		c, err := getClientProjects()
+		if err != nil {
+			t.Errorf("Client.getClientProjects() error = %v", err)
+			return
+		}
+		got, err := c.GetProjects(nil)
+		if err != nil {
+			t.Errorf("Client.GetProjects() error = %v", err)
+			return
+		}
+		t.Logf("GetProjects - number of projects %d", len(got))
+	})
+}
+
+func TestClient_GetProjects_Search(t *testing.T) {
+	t.Run("test", func(t *testing.T) {
+		c, err := getClientProjects()
+		if err != nil {
+			t.Errorf("Client.getClientProjects() error = %v", err)
+			return
+		}
+
+		searchString := "monitor"
+
+		got, err := c.GetProjects(&searchString)
+		if err != nil {
+			t.Errorf("Client.GetProjects() error = %v", err)
+			return
+		}
+		t.Logf("GetProjects - number of projects %d", len(got))
+	})
+}
+
+// Insure the integration test root level group exists
+func TestClient_AddRootGroup(t *testing.T) {
+	t.Run("test", func(t *testing.T) {
+		c, err := getClientProjects()
+		if err != nil {
+			t.Errorf("Client.getClientProjects() error = %v", err)
+			return
+		}
+
+		path := "integration-root-group"
+		name := "integration root group"
+		description := "Integration Test Root Level Group"
+
+		group, statusCode, err := c.GetGroupByFullPath(&path)
+		if err != nil {
+			// dont fail if group already exists
+			t.Errorf("Client.GetGroupByFullPath() error = %v %d", err, statusCode)
+			return
+		}
+
+		if statusCode == http.StatusFound {
+			integrationRootGroupID = group.ID
+			t.Logf("AddGroup %s %s %s %s %d", group.Name, group.Path, group.FullPath, group.WebURL, statusCode)
+		} else {
+			groupOpts := gogitlab.CreateGroupOptions{Name: &name, Path: &path, Description: &description}
+			got, statusCode, err := c.AddGroup(groupOpts)
+
+			if err != nil {
+				// dont fail if group already exists
+				t.Logf("Client.AddGroup() error = %v %d", err, statusCode)
+			} else {
+				integrationRootGroupID = got.ID
+				t.Logf("AddGroup %s %s %s %s %d", got.Name, got.Path, got.FullPath, got.WebURL, statusCode)
+			}
+		}
+	})
+}
+
+// add groups under the integration test root level group
+func TestClient_AddProjects(t *testing.T) {
+	t.Run("test", func(t *testing.T) {
+		c, err := getClientProjects()
+		if err != nil {
+			t.Errorf("Client.getClientProjects() error = %v", err)
+			return
+		}
+
+		for i := 1; i <= projectsTestItemCount; i++ {
+			path := testProjectsPrefix + "-project-" + fmt.Sprintf("%d", i)
+			name := testProjectsPrefix + " project " + fmt.Sprintf("%d", i)
+			description := "My fancy test project " + fmt.Sprintf("%d", i)
+
+			projectOpts := gogitlab.CreateProjectOptions{
+				Name:        &name,
+				Path:        &path,
+				Description: &description,
+				NamespaceID: &integrationRootGroupID,
+			}
+			got, statusCode, err := c.AddProject(projectOpts)
+
+			if err != nil {
+				t.Errorf("Client.AddProject() error = %v %d", err, statusCode)
+			} else {
+				t.Logf("AddProject %s %s %s %s %d", got.Name, got.Path, got.PathWithNamespace, got.WebURL, statusCode)
+			}
+		}
+
+	})
+}
+
+func TestClient_UpdateProject(t *testing.T) {
+	t.Run("test", func(t *testing.T) {
+		c, err := getClientProjects()
+		if err != nil {
+			t.Errorf("Client.getClientProjects() error = %v", err)
+			return
+		}
+
+		// create a group to contain test objects
+		path := testProjectsPrefix + "-project-update"
+		name := testProjectsPrefix + " project update"
+		description := "My fancy test project "
+
+		projectOpts := gogitlab.CreateProjectOptions{
+			Name:        &name,
+			Path:        &path,
+			Description: &description,
+			NamespaceID: &integrationRootGroupID,
+		}
+		newProject, statusCode, err := c.AddProject(projectOpts)
+		if err != nil {
+			t.Errorf("Client.AddProject() error = %v", err)
+			return
+		}
+		t.Logf("    created project %s path %s status code %d", newProject.Name, newProject.PathWithNamespace, statusCode)
+
+		// update user
+		testDescription := "Updated Description"
+		updateProjectOptions := gogitlab.EditProjectOptions{Description: &testDescription}
+		updatedProject, statusCode, err := c.UpdateProject(newProject.ID, updateProjectOptions)
+		if err != nil {
+			t.Errorf("Client.UpdateProject() error = %v", err)
+			return
+		}
+		t.Logf("UpdateProject: %s %d", updatedProject.Description, statusCode)
+
+		// cleanup
+		statusCode, _ = c.DeleteProject(newProject.ID, 0, 0)
+		t.Logf("DeleteProject no wait statusCode: %d", statusCode)
+
+	})
+}
+
+
+func TestClient_deleteProjects(t *testing.T) {
+	t.Run("test", func(t *testing.T) {
+		c, err := getClientProjects()
+		if err != nil {
+			t.Errorf("Client.getClient() error = %v", err)
+			return
+		}
+
+		search := testProjectsPrefix
+		projectList, err := c.GetProjects(&search)
+		if err != nil {
+			t.Errorf("Client.GetProjects() error = %v", err)
+			return
+		}
+
+		for x := 0; x < len(projectList); x++ {
+			project := projectList[x]
+			statusCode, err := c.DeleteProject(project.ID, 100, 1200)
+
+			if err != nil {
+				t.Errorf("Client.DeleteProject() error = %v %d", err, statusCode)
+			} else {
+				t.Logf("DeleteProject %s %d", project.Name, statusCode)
+			}
+		}
+
+	})
+}
diff --git a/integration-tests/gitlab/api/gitlab_api_users_test.go b/integration-tests/gitlab/api/gitlab_api_users_test.go
index 28f3f7461d148432f41b1c747f25540c15b6ca12..b9a416d134cd5a76b21f79a9c7f13cf2415394c9 100644
--- a/integration-tests/gitlab/api/gitlab_api_users_test.go
+++ b/integration-tests/gitlab/api/gitlab_api_users_test.go
@@ -13,9 +13,10 @@ import (
 )
 
 const testItemCount = 65
+const testUserPrefix = "IntTestUser"
 
 // getClient -
-func getClient_Users() (gitlab.Client, error) {
+func getClientUsers() (gitlab.Client, error) {
 	gitlabAPIURL, ok := os.LookupEnv("GITLAB_API_URL")
 	if !ok {
 		return gitlab.Client{}, errors.New("env variable GITLAB_API_URL undefinded")
@@ -31,7 +32,7 @@ func getClient_Users() (gitlab.Client, error) {
 //TestClient_getUsers -
 func TestClient_getUsers(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Users()
+		c, err := getClientUsers()
 		if err != nil {
 			t.Errorf("Client.GetUsers() error = %v", err)
 			return
@@ -48,18 +49,24 @@ func TestClient_getUsers(t *testing.T) {
 // TestClient_addUsers -
 func TestClient_addUsers(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Users()
+		c, err := getClientUsers()
 		if err != nil {
 			t.Errorf("Client.GetUsers() error = %v", err)
 			return
 		}
 
 		for i := 1; i <= testItemCount; i++ {
-			username := "testuser" + fmt.Sprintf("%d", i)
+			username := testUserPrefix + fmt.Sprintf("%d", i)
 			name := "test user name " + fmt.Sprintf("%d", i)
 			email := username + "@email.com"
-			userObj := gogitlab.User{Username: username, Email: email, Name: name}
-			got, statusCode, err := c.AddUser(&userObj, "password")
+			pw := "spacejam"
+			userOpts := gogitlab.CreateUserOptions{
+				Username: &username,
+				Email:    &email,
+				Name:     &name,
+				Password: &pw,
+			}
+			got, statusCode, err := c.AddUser(&userOpts)
 
 			if err != nil {
 				t.Errorf("Client.AddUser() error = %v %d", err, statusCode)
@@ -73,53 +80,73 @@ func TestClient_addUsers(t *testing.T) {
 
 func TestClient_UpdateUser(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Users()
+		c, err := getClientUsers()
 		if err != nil {
 			t.Errorf("Client.GetUsers() error = %v", err)
 			return
 		}
 		// create a user
-		username := "testupdateuser01"
+		username := testUserPrefix + "update01"
 		name := "test update user name 01"
 		email := username + "@email.com"
-		userObj := gogitlab.User{Username: username, Email: email, Name: name}
-		user, statusCode, err := c.AddUser(&userObj, "password")
-		t.Logf("    created user %s status code %d", username, statusCode)
+		pw := "spacejam"
+		userOpts := gogitlab.CreateUserOptions{
+			Username: &username,
+			Email:    &email,
+			Name:     &name,
+			Password: &pw,
+		}
+
+		// add a test user to modify
+		user, statusCode, err := c.AddUser(&userOpts)
+		if err != nil {
+			t.Errorf("Client.GetUserByUsername() error = %v", err)
+			return
+		}
+		t.Logf("AddUser: %s %d", user.Username, statusCode)
+		
 
-		// get user
+		// get test test user
 		user, statusCode, err = c.GetUserByUsername(&username)
 		if err != nil {
 			t.Errorf("Client.GetUserByUsername() error = %v", err)
 			return
 		}
-		t.Logf("GetUserByUsername: %s", user.Username)
+		t.Logf("GetUserByUsername: %s %d", user.Username, statusCode)
 
-		// update user
+		// update test user
 		testName := "Updated Username 01"
 		modifyUserOptions := gogitlab.ModifyUserOptions{Name: &testName}
-		_, statusCode, err = c.UpdateUser(user.ID, &modifyUserOptions)
+		updatedUser, statusCode, err := c.UpdateUser(user.ID, &modifyUserOptions)
+		if err != nil {
+			t.Errorf("Client.GetUserByUsername() error = %v", err)
+			return
+		}
+		t.Logf("UpdateUser success: %s %d", updatedUser.Username,statusCode)
 
-		// get user
+		// get test user again
 		user, statusCode, err = c.GetUserByUsername(&username)
 		if err != nil {
 			t.Errorf("Client.GetUserByUsername() error = %v", err)
 			return
 		}
-		t.Logf("GetUserByUsername success: %s", user.Username)
-		if ( user.Name != testName) {
+		t.Logf("GetUserByUsername success: %s %d", user.Username,statusCode)
+
+		// confirm update occured
+		if user.Name != testName {
 			t.Errorf("TestClient_UpdateUser expected %s got %s", testName, user.Name)
 		} else {
 			t.Logf("TestClient_UpdateUser success. updated Name: %s for username: %s", user.Username, user.Name)
 		}
 
 		// cleanup
-		c.DeleteUser(user.ID,0,0)
+		c.DeleteUser(user.ID, 0, 0)
 
 	})
 }
 func TestClient_getUsersCount(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Users()
+		c, err := getClientUsers()
 		if err != nil {
 			t.Errorf("Client.getClient() error = %v", err)
 			return
@@ -134,18 +161,18 @@ func TestClient_getUsersCount(t *testing.T) {
 }
 func TestClient_deleteUsers(t *testing.T) {
 	t.Run("test", func(t *testing.T) {
-		c, err := getClient_Users()
+		c, err := getClientUsers()
 		if err != nil {
 			t.Errorf("Client.GetUsers() error = %v", err)
 			return
 		}
 
 		for i := 1; i <= testItemCount; i++ {
-			username := "testuser" + fmt.Sprintf("%d", i)
+			username := testUserPrefix + fmt.Sprintf("%d", i)
 			statusCode, err := c.DeleteUserByUsername(username, 100, 200)
 
 			if err != nil {
-				t.Errorf("Client.DeleteUser() error = %v %d", err, statusCode)
+				t.Errorf("Client.DeleteUserByUsername() error = %v %d", err, statusCode)
 			} else {
 				t.Logf("Deleted user %s %d", username, statusCode)
 			}
@@ -153,4 +180,3 @@ func TestClient_deleteUsers(t *testing.T) {
 
 	})
 }
-