diff --git a/apis/gitlab/v1alpha1/group_types.go b/apis/gitlab/v1alpha1/group_types.go
index c2f1feb02c2f9111bc180d2d784e2ef76033370f..7700f96f32432d7b74183e2b18cfb05ec5e416ad 100644
--- a/apis/gitlab/v1alpha1/group_types.go
+++ b/apis/gitlab/v1alpha1/group_types.go
@@ -30,10 +30,6 @@ type GroupSpec struct {
 	// +kubebuilder:validation:Optional
 	Description string `json:"description"`
 
-	// Owner is the Gitlab Username for the group owner
-	// +kubebuilder:validation:Optional
-	Owner string `json:"owner"`
-
 	// GitlabCredentialsName is the name of the object in this namespace that contains authentication
 	// information for logging into the
 	GitlabCredentialsName string `json:"gitlabCredentialsName"`
diff --git a/apis/gitlab/v1alpha1/project_types.go b/apis/gitlab/v1alpha1/project_types.go
index b61b3de140e5d7ab69b26dc16c64f7f60b78c709..c16307e95ff39e640ea161ab5fd15278fc0a8a61 100644
--- a/apis/gitlab/v1alpha1/project_types.go
+++ b/apis/gitlab/v1alpha1/project_types.go
@@ -20,11 +20,12 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )
 
-// EDIT THIS FILE!  THIS IS SCAFFOLDING FOR YOU TO OWN!
-// NOTE: json tags are required.  Any new fields you add must have json tags for the fields to be serialized.
-
 // ProjectSpec defines the desired state of Project
 type ProjectSpec struct {
+	// GroupID is the id of the GitLab Group id that owns this project
+	// +kubebuilder:validation:required
+	GroupID  int64`json:"groupId"`
+
 	// Name is the name of this Project
 	// +kubebuilder:validation:required
 	Name string `json:"name"`
@@ -36,34 +37,29 @@ type ProjectSpec struct {
 	// ImpactLevel is the RMF Impact Level for this Project
 	// +kubebuilder:validation:Enum=2;4;5;6
 	// +kubebuiler:validation:required
-	ImpactLevel string `json:"impact_level"`
+	ImpactLevel string `json:"impactLevel"`
 
 	// StorageTypes is the storage types that will be added to the Project
 	// +kubebuiler:validation:optional
-	StorageTypes []string `json:"storage_types:omitempty"`
+	StorageTypes []string `json:"storageTypes:omitempty"`
 
 	// VirtualService is the type of virtual service that will be created for this Project
 	// +kubebuilder:default="Default"
-	VirtualService string `json:"virtual_service"`
+	VirtualService string `json:"virtualService"`
 
 	// ServicePort is the port for the virtual service for the application served by this Project
-	ServicePort int32 `json:"service_port,omitempty"`
+	ServicePort int32 `json:"servicePort,omitempty"`
 
 	// Language is the programming language of the Project for this application.
 	// +kubebuiler:validation:required
 	Language string `json:"language"` //TODO: Consider a custom type / annotation
 
-	// test Dummy is an example field of Project. Edit project_types.go to remove/update
-	Dummy string `json:"dummy,omitempty"`
 }
 
 // ProjectStatus defines the observed state of Project
 type ProjectStatus struct {
 	// URL is the url for the project in GitLab
 	URL string `json:"url"`
-
-	// test Dummy is an example field of Project. Edit project_types.go to remove/update
-	Dummy string `json:"dummy,omitempty"`
 }
 
 //+kubebuilder:object:root=true
diff --git a/apis/gitlab/v1alpha1/project_scaffold_test.go b/apis/gitlab/v1alpha1/project_types_test.go
similarity index 90%
rename from apis/gitlab/v1alpha1/project_scaffold_test.go
rename to apis/gitlab/v1alpha1/project_types_test.go
index 14cba536432ed323725b973aa1d7766803d56248..a44ce93f31e431e54fe7eeb845cbd7988dd91fdf 100644
--- a/apis/gitlab/v1alpha1/project_scaffold_test.go
+++ b/apis/gitlab/v1alpha1/project_types_test.go
@@ -28,11 +28,9 @@ type testVarsProject = struct {
 	objectItems2 []Project
 	objectList2  ProjectList
 
-	// leave scaffold Foo value for testing?
 	testObjectSpec1 ProjectSpec
 	testObjectSpec2 ProjectSpec
 
-	// leave scaffold Foo value for testing?
 	testObjectStatus1 ProjectStatus
 	testObjectStatus2 ProjectStatus
 }
@@ -66,13 +64,11 @@ func initVarsProject() testVarsProject {
 	// test_object_list = ProjectList(objectList1MetaType,nil,object_items)
 	testVars.objectList2 = ProjectList{TypeMeta: objectList2MetaType, Items: objectItems2}
 
-	// leave scaffold Foo value for testing?
-	testVars.testObjectSpec1 = ProjectSpec{Dummy: testVars.testSpec, StorageTypes: []string{"type1", "type2"}}
-	testVars.testObjectSpec2 = ProjectSpec{Dummy: "other value"}
+	testVars.testObjectSpec1 = ProjectSpec{ StorageTypes: []string{"type1", "type2"}}
+	testVars.testObjectSpec2 = ProjectSpec{ Name: "a name"}
 
-	// leave scaffold Foo value for testing?
-	testVars.testObjectStatus1 = ProjectStatus{Dummy: testVars.testStatus}
-	testVars.testObjectStatus2 = ProjectStatus{Dummy: "other value"}
+	testVars.testObjectStatus1 = ProjectStatus{ URL: testVars.testStatus}
+	testVars.testObjectStatus2 = ProjectStatus{ URL: "other value"}
 
 	return testVars
 }
@@ -221,8 +217,8 @@ func TestDeepCopy_DeepCopySpec_Project(t *testing.T) {
 
 	newObjectList := lTestVars.testObjectSpec1.DeepCopy()
 
-	got := newObjectList.Dummy
-	want := lTestVars.expectedSpec
+	got := newObjectList.Name
+	want := lTestVars.testObjectSpec1.Name
 
 	if got != want {
 		t.Errorf("got %s want %s", got, want)
@@ -241,8 +237,8 @@ func TestDeepCopy_DeepCopySpecInto_Project(t *testing.T) {
 
 	lTestVars.testObjectSpec1.DeepCopyInto(&lTestVars.testObjectSpec2)
 
-	got := lTestVars.testObjectSpec2.Dummy
-	want := lTestVars.expectedSpec
+	got := lTestVars.testObjectSpec2.Name
+	want := lTestVars.testObjectSpec1.Name
 
 	if got != want {
 		t.Errorf("got %s want %s", got, want)
@@ -256,7 +252,7 @@ func TestDeepCopy_DeepCopyStatus_Project(t *testing.T) {
 
 	newObjectStatus := lTestVars.testObjectStatus1.DeepCopy()
 
-	got := newObjectStatus.Dummy
+	got := newObjectStatus.URL
 	want := lTestVars.expectedStatus
 
 	if got != want {
@@ -278,7 +274,7 @@ func TestDeepCopy_DeepCopyStatusInto_Project(t *testing.T) {
 
 	lTestVars.testObjectStatus1.DeepCopyInto(&lTestVars.testObjectStatus2)
 
-	got := lTestVars.testObjectStatus2.Dummy
+	got := lTestVars.testObjectStatus2.URL
 	want := lTestVars.expectedStatus
 
 	if got != want {
diff --git a/controllers/gitlab/gitlab_client.go b/controllers/gitlab/gitlab_client.go
index 57999a45219a1679388f6482a674d5e3463ecc11..d9d574b37a4e1b545e1420fc84b2cf402e189603 100644
--- a/controllers/gitlab/gitlab_client.go
+++ b/controllers/gitlab/gitlab_client.go
@@ -39,7 +39,7 @@ func (c ClientImpl) ListGroupsByName(name string) ([]*gitlab.Group, *gitlab.Resp
 // CreateGroup is a facade for the go-gitlab client.Groups.CreateGroup
 func (c ClientImpl) CreateGroup(name string, description string) (*gitlab.Group, *gitlab.Response, error) {
 	opt := gitlab.CreateGroupOptions{
-		Name:        &name,
+		Name: &name,
 		Description: &description,
 	}
 	return c.client.Groups.CreateGroup(&opt)
@@ -48,7 +48,7 @@ func (c ClientImpl) CreateGroup(name string, description string) (*gitlab.Group,
 // UpdateGroup is a facade for the go-gitlab client.Group.UpdateGroup
 func (c ClientImpl) UpdateGroup(id string, name string, descrption string) (*gitlab.Group, *gitlab.Response, error) {
 	opt := gitlab.UpdateGroupOptions{
-		Name:        &name,
+		Name: &name,
 		Description: &descrption,
 	}
 	return c.client.Groups.UpdateGroup(id, &opt)
diff --git a/controllers/gitlab/group_controller.go b/controllers/gitlab/group_controller.go
index 46f433d50486e1d095819eec119f0a0eeef75ba6..844c27c8cf1a0b9228c89a309e600e67aeb00477 100644
--- a/controllers/gitlab/group_controller.go
+++ b/controllers/gitlab/group_controller.go
@@ -33,18 +33,18 @@ import (
 
 // Errors
 const (
-	errorUnableToFetchGroup             = "unable to fetch group"
-	errorUnableToFetchGitlabCredentials = "unable to fetch gitlab credentials"
-	errorUnableToFetchSecret            = "unable to fetch secret from gitlab credentials"
-	errorUnableToCreateGitlabClient     = "unable to create gitlab client"
-	errorWhileSearchingGroups           = "Error while searching groups."
-	errorWhileCreatingGitlabGroup       = "Error while creating GitLab group."
-	errorWhileUpdatingGitlabGroup       = "Error while updating GitLab group."
-	errorUnableToUpdateStatus           = "Unable to update status."
-	errorUnableToProcessProjects        = "Unable to process projects"
-	errorTryingToCreateProject          = "Error trying to create project"
-	errorLookingUpProject               = "Error looking up project"
-	errorUpdatingProject                = "Error updating project"
+ errorUnableToFetchGroup = "unable to fetch group"
+ errorUnableToFetchGitlabCredentials = "unable to fetch gitlab credentials"
+ errorUnableToFetchSecret = "unable to fetch secret from gitlab credentials"
+ errorUnableToCreateGitlabClient = "unable to create gitlab client"
+ errorWhileSearchingGroups = "Error while searching groups."
+ errorWhileCreatingGitlabGroup = "Error while creating GitLab group."
+ errorWhileUpdatingGitlabGroup = "Error while updating GitLab group."
+ errorUnableToUpdateStatus = "Unable to update status."
+ errorUnableToProcessProjects = "Unable to process projects"
+ errorTryingToCreateProject = "Error trying to create project"
+ errorLookingUpProject = "Error looking up project"
+ errorUpdatingProject = "Error updating project"	 
 )
 
 // Group Status
@@ -57,6 +57,7 @@ const (
 
 const valkyrie = "valkyrie"
 
+
 // GroupReconciler reconciles the state of a Gitlab Group, for each reconciliation loop it will log in to Gitlab
 // with credentials in the secret provided.  It will then check the state of the Group, and create it if necessary.
 type GroupReconciler struct {
@@ -141,7 +142,7 @@ func (r *GroupReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl
 
 	if !found {
 		if gitlabGroup, _, err = r.createGroup(group); err != nil {
-
+			
 			log.Error(err, errorWhileCreatingGitlabGroup, "group", group)
 			return ctrl.Result{Requeue: true}, err
 		}
@@ -201,7 +202,7 @@ func (r *GroupReconciler) createGroup(group *gitlabv1alpha1.Group) (*gitlab.Grou
 }
 
 func (r *GroupReconciler) updateGroup(group *gitlabv1alpha1.Group) (*gitlab.Group, *gitlab.Response, error) {
-	gitlabGroup, response, err := r.gitlabClient.UpdateGroup(group.ObjectMeta.Annotations["ID"], group.Spec.Name, group.Spec.Description)
+	gitlabGroup, response, err := 	r.gitlabClient.UpdateGroup(group.ObjectMeta.Annotations["ID"], group.Spec.Name, group.Spec.Description)
 
 	if err == nil {
 		group.Status.State = GroupOK
@@ -213,13 +214,14 @@ func (r *GroupReconciler) updateGroup(group *gitlabv1alpha1.Group) (*gitlab.Grou
 	return gitlabGroup, response, err
 }
 
+
 func (r *GroupReconciler) processProjects(ctx context.Context, group *gitlabv1alpha1.Group, specs []gitlabv1alpha1.ProjectSpec) error {
 	for _, projectSpec := range specs {
 		if project, foundProject, err := r.getProject(ctx, group, projectSpec); err != nil {
 			r.Log.Error(err, errorLookingUpProject, "name", projectSpec.Name)
 			return err
 		} else if foundProject {
-			if _, err := r.updateProject(ctx, projectSpec, project); err != nil {
+			if _, err := r.updateProject(ctx, 0, projectSpec, project); err != nil {
 
 				r.Log.Error(err, errorUpdatingProject, "project", project)
 			}
@@ -267,7 +269,7 @@ func (r *GroupReconciler) createProject(ctx context.Context, group *gitlabv1alph
 				},
 			},
 		},
-		Spec: gitlabv1alpha1.ProjectSpec{
+		Spec:       gitlabv1alpha1.ProjectSpec{
 			Name:           spec.Name,
 			Path:           spec.Path,
 			ImpactLevel:    spec.ImpactLevel,
@@ -279,7 +281,8 @@ func (r *GroupReconciler) createProject(ctx context.Context, group *gitlabv1alph
 	})
 }
 
-func (r *GroupReconciler) updateProject(ctx context.Context, spec gitlabv1alpha1.ProjectSpec, project *gitlabv1alpha1.Project) (*gitlabv1alpha1.Project, error) {
+func (r *GroupReconciler) updateProject(ctx context.Context, groupID int64, spec gitlabv1alpha1.ProjectSpec, project *gitlabv1alpha1.Project) (*gitlabv1alpha1.Project, error) {
+	project.Spec.GroupID = groupID
 	project.Spec.Name = spec.Name
 	project.Spec.Path = spec.Path
 	project.Spec.ImpactLevel = spec.ImpactLevel
diff --git a/controllers/gitlab/group_controller_test.go b/controllers/gitlab/group_controller_test.go
index c97e08658e42cfa98a8350dfe8d056a157431456..6365635c0b1566145afd34a2d03a7f5ada36cc17 100755
--- a/controllers/gitlab/group_controller_test.go
+++ b/controllers/gitlab/group_controller_test.go
@@ -1,1141 +1,1157 @@
-package gitlab
-
-import (
-	"context"
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-	"github.com/xanzy/go-gitlab"
-	v1 "k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/types"
-	"net/http"
-	ctrl "sigs.k8s.io/controller-runtime"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-	gitlabv1alpha1 "valkyrie.dso.mil/valkyrie-api/apis/gitlab/v1alpha1"
-)
-
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("it looks up the API Object", func() {
-		Context("the API Object isn't found", func() {
-			loggerMock := MockLogger{
-				WithValuesKeysAndValues: nil,
-				WithValuesCalled:        false,
-				WithNameValue:           "",
-				WithNameCalled:          false,
-			}
-			contextMock := context.TODO()
-			clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-				return nil
-			}}}
-			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-			requestMock := ctrl.Request{}
-			sut := GroupReconciler{
-				Client: &clientMock,
-				Log:    &loggerMock,
-				Scheme: scheme,
-			}
-			result, err := sut.Reconcile(contextMock, requestMock)
-			It("should log the error", func() {
-				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-				Expect(loggerMock.loggedMessage).To(Equal("unable to fetch group"))
-			})
-			It("should return an empty result, and ignore the error.", func() {
-				Expect(result).Should(Equal(ctrl.Result{}))
-				Expect(err).Should(BeNil())
-			})
-		})
-	})
-})
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("it looks up the GitlabCredentals", func() {
-		Context("gitlab credentials are not found", func() {
-			loggerMock := MockLogger{
-				WithValuesKeysAndValues: nil,
-				WithValuesCalled:        false,
-				WithNameValue:           "",
-				WithNameCalled:          false,
-			}
-			contextMock := context.TODO()
-			clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-				return nil
-			}}}
-			requestMock := ctrl.Request{}
-			sut := GroupReconciler{
-				Client: &clientMock,
-				Log:    &loggerMock,
-				Scheme: scheme,
-			}
-			requestMock.NamespacedName = types.NamespacedName{
-				Namespace: "default",
-				Name:      "testGroup",
-			}
-			clientMock.GetFunction = nil
-			group := gitlabv1alpha1.Group{
-				TypeMeta:   metav1.TypeMeta{},
-				ObjectMeta: metav1.ObjectMeta{},
-				Spec:       gitlabv1alpha1.GroupSpec{},
-				Status:     gitlabv1alpha1.GroupStatus{},
-			}
-			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-			clientMock.expectedObjects[requestMock.NamespacedName] = &group
-			result, err := sut.Reconcile(contextMock, requestMock)
-			It("should log the error", func() {
-				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-				Expect(loggerMock.loggedMessage).To(Equal("unable to fetch gitlab credentials"))
-			})
-			It("should return a reconcile result, and the error.", func() {
-				Expect(result).To(Equal(ctrl.Result{
-					Requeue: true,
-				}))
-				Expect(err).ToNot(BeNil())
-			})
-		})
-	})
-})
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("getting the secret from the GitlabCredentials", func() {
-		Context("Secret doesn't exist", func() {
-			loggerMock := MockLogger{
-				WithValuesKeysAndValues: nil,
-				WithValuesCalled:        false,
-				WithNameValue:           "",
-				WithNameCalled:          false,
-			}
-			contextMock := context.TODO()
-			clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-				return nil
-			}}}
-			requestMock := ctrl.Request{}
-			sut := GroupReconciler{
-				Client: &clientMock,
-				Log:    &loggerMock,
-				Scheme: scheme,
-			}
-			requestMock.NamespacedName = types.NamespacedName{
-				Namespace: "default",
-				Name:      "testGroup",
-			}
-			gitlabCred := gitlabv1alpha1.GitlabCredentials{
-				TypeMeta:   metav1.TypeMeta{},
-				ObjectMeta: metav1.ObjectMeta{},
-				Spec: gitlabv1alpha1.GitlabCredentialsSpec{
-					URL:      "https://example.com",
-					Username: "ausername",
-					AccessToken: v1.SecretReference{
-						Name:      "asecret",
-						Namespace: "default",
-					},
-				},
-				Status: gitlabv1alpha1.GitlabCredentialsStatus{},
-			}
-			group := gitlabv1alpha1.Group{
-				TypeMeta:   metav1.TypeMeta{},
-				ObjectMeta: metav1.ObjectMeta{},
-				Spec: gitlabv1alpha1.GroupSpec{
-					Name:                  "agroup",
-					GitlabCredentialsName: "gitlab-credentials",
-					ProjectSpecs:          nil,
-				},
-				Status: gitlabv1alpha1.GroupStatus{},
-			}
-
-			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-			clientMock.expectedObjects[requestMock.NamespacedName] = &group
-			clientMock.expectedObjects[types.NamespacedName{
-				Namespace: "default",
-				Name:      group.Spec.GitlabCredentialsName,
-			}] = &gitlabCred
-			result, err := sut.Reconcile(contextMock, requestMock)
-			It("Should log an error regarding the missing credentials", func() {
-				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-				Expect(loggerMock.loggedMessage).To(Equal("unable to fetch secret from gitlab credentials"))
-			})
-			It("Should return a requeue result and an error", func() {
-				Expect(result).To(Equal(ctrl.Result{Requeue: true}))
-				Expect(err).ToNot(BeNil())
-			})
-		})
-	})
-})
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("logging in to GitLab", func() {
-		Context("can't create client", func() {
-			loggerMock := &MockLogger{
-				WithValuesKeysAndValues: nil,
-				WithValuesCalled:        false,
-				WithNameValue:           "",
-				WithNameCalled:          false,
-			}
-			contextMock := context.TODO()
-			clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-				return nil
-			}}}
-			requestMock := ctrl.Request{}
-			sut := GroupReconciler{
-				Client: &clientMock,
-				Log:    loggerMock,
-				Scheme: scheme,
-			}
-			requestMock.NamespacedName = types.NamespacedName{
-				Namespace: "default",
-				Name:      "testGroup",
-			}
-			gitlabCred := gitlabv1alpha1.GitlabCredentials{
-				TypeMeta:   metav1.TypeMeta{},
-				ObjectMeta: metav1.ObjectMeta{},
-				Spec: gitlabv1alpha1.GitlabCredentialsSpec{
-					URL:      "https://example.com",
-					Username: "ausername",
-					AccessToken: v1.SecretReference{
-						Name:      "asecret",
-						Namespace: "default",
-					},
-				},
-				Status: gitlabv1alpha1.GitlabCredentialsStatus{},
-			}
-			group := gitlabv1alpha1.Group{
-				TypeMeta:   metav1.TypeMeta{},
-				ObjectMeta: metav1.ObjectMeta{},
-				Spec: gitlabv1alpha1.GroupSpec{
-					Name:                  "agroup",
-					GitlabCredentialsName: "gitlab-credentials",
-					ProjectSpecs:          nil,
-				},
-				Status: gitlabv1alpha1.GroupStatus{},
-			}
-			secretNamespacedName := types.NamespacedName{
-				Namespace: gitlabCred.Spec.AccessToken.Namespace,
-				Name:      gitlabCred.Spec.AccessToken.Name,
-			}
-			stringData := map[string]string{"accessToken": "password"}
-			secret := v1.Secret{
-				TypeMeta:   metav1.TypeMeta{},
-				ObjectMeta: metav1.ObjectMeta{},
-				StringData: stringData,
-				Type:       "opaque",
-			}
-			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-			clientMock.expectedObjects[requestMock.NamespacedName] = &group
-			clientMock.expectedObjects[types.NamespacedName{
-				Namespace: "default",
-				Name:      group.Spec.GitlabCredentialsName,
-			}] = &gitlabCred
-			clientMock.expectedObjects[secretNamespacedName] = &secret
-			sut.gitlabClient = &MockGitlabClient{
-				newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
-					return nil, &MockError{
-						message: "mocked error",
-					}
-				},
-			}
-			result, err := sut.Reconcile(contextMock, requestMock)
-			It("Should log the failure", func() {
-				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-				Expect(loggerMock.loggedMessage).To(Equal(errorUnableToCreateGitlabClient))
-			})
-			It("Should return an error", func() {
-				Expect(err).ToNot(BeNil())
-			})
-			It("should requeue the group", func() {
-				Expect(result).To(Equal(ctrl.Result{Requeue: true}))
-			})
-		})
-	})
-})
-
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("groupExists fails", func() {
-		loggerMock := &MockLogger{
-			WithValuesKeysAndValues: nil,
-			WithValuesCalled:        false,
-			WithNameValue:           "",
-			WithNameCalled:          false,
-		}
-		contextMock := context.TODO()
-		clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-			return nil
-		}}}
-		requestMock := ctrl.Request{}
-		sut := GroupReconciler{
-			Client: &clientMock,
-			Log:    loggerMock,
-			Scheme: scheme,
-		}
-		requestMock.NamespacedName = types.NamespacedName{
-			Namespace: "default",
-			Name:      "testGroup",
-		}
-		gitlabCred := gitlabv1alpha1.GitlabCredentials{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GitlabCredentialsSpec{
-				URL:      "https://example.com",
-				Username: "ausername",
-				AccessToken: v1.SecretReference{
-					Name:      "asecret",
-					Namespace: "default",
-				},
-			},
-			Status: gitlabv1alpha1.GitlabCredentialsStatus{},
-		}
-		group := gitlabv1alpha1.Group{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GroupSpec{
-				Name:                  "agroup",
-				GitlabCredentialsName: "gitlab-credentials",
-				ProjectSpecs:          nil,
-			},
-			Status: gitlabv1alpha1.GroupStatus{},
-		}
-		secretNamespacedName := types.NamespacedName{
-			Namespace: gitlabCred.Spec.AccessToken.Namespace,
-			Name:      gitlabCred.Spec.AccessToken.Name,
-		}
-		stringData := map[string]string{"accessToken": "password"}
-		secret := v1.Secret{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			StringData: stringData,
-			Type:       "opaque",
-		}
-		clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-		clientMock.expectedObjects[requestMock.NamespacedName] = &group
-		clientMock.expectedObjects[types.NamespacedName{
-			Namespace: "default",
-			Name:      group.Spec.GitlabCredentialsName,
-		}] = &gitlabCred
-		clientMock.expectedObjects[secretNamespacedName] = &secret
-		sut.gitlabClient = &MockGitlabClient{
-			newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
-				return &gitlab.Client{}, nil
-			},
-			listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-				return nil, &gitlab.Response{
-						Response: &http.Response{
-							Status:           "",
-							StatusCode:       0,
-							Proto:            "",
-							ProtoMajor:       0,
-							ProtoMinor:       0,
-							Header:           nil,
-							Body:             nil,
-							ContentLength:    0,
-							TransferEncoding: nil,
-							Close:            false,
-							Uncompressed:     false,
-							Trailer:          nil,
-							Request:          nil,
-							TLS:              nil,
-						},
-						TotalItems:   0,
-						TotalPages:   0,
-						ItemsPerPage: 0,
-						CurrentPage:  0,
-						NextPage:     0,
-						PreviousPage: 0,
-					}, &MockError{
-						message: "Error",
-					}
-			},
-		}
-		result, err := sut.Reconcile(contextMock, requestMock)
-		It("should requeue the object", func() {
-			Expect(result).To(Equal(ctrl.Result{Requeue: true}))
-		})
-		It("should log the error", func() {
-			Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-			Expect(loggerMock.loggedMessage).To(Equal(errorWhileSearchingGroups))
-		})
-		It("should return an error", func() {
-			Expect(err).NotTo(BeNil())
-		})
-	})
-})
-
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("createGroup fails", func() {
-		loggerMock := &MockLogger{
-			WithValuesKeysAndValues: nil,
-			WithValuesCalled:        false,
-			WithNameValue:           "",
-			WithNameCalled:          false,
-		}
-		contextMock := context.TODO()
-		clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-			return nil
-		}}}
-		requestMock := ctrl.Request{}
-		sut := GroupReconciler{
-			Client: &clientMock,
-			Log:    loggerMock,
-			Scheme: scheme,
-		}
-		requestMock.NamespacedName = types.NamespacedName{
-			Namespace: "default",
-			Name:      "testGroup",
-		}
-		gitlabCred := gitlabv1alpha1.GitlabCredentials{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GitlabCredentialsSpec{
-				URL:      "https://example.com",
-				Username: "ausername",
-				AccessToken: v1.SecretReference{
-					Name:      "asecret",
-					Namespace: "default",
-				},
-			},
-			Status: gitlabv1alpha1.GitlabCredentialsStatus{},
-		}
-		group := gitlabv1alpha1.Group{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GroupSpec{
-				Name:                  "agroup",
-				GitlabCredentialsName: "gitlab-credentials",
-				ProjectSpecs:          nil,
-			},
-			Status: gitlabv1alpha1.GroupStatus{},
-		}
-		secretNamespacedName := types.NamespacedName{
-			Namespace: gitlabCred.Spec.AccessToken.Namespace,
-			Name:      gitlabCred.Spec.AccessToken.Name,
-		}
-		stringData := map[string]string{"accessToken": "password"}
-		secret := v1.Secret{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			StringData: stringData,
-			Type:       "opaque",
-		}
-		clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-		clientMock.expectedObjects[requestMock.NamespacedName] = &group
-		clientMock.expectedObjects[types.NamespacedName{
-			Namespace: "default",
-			Name:      group.Spec.GitlabCredentialsName,
-		}] = &gitlabCred
-		clientMock.expectedObjects[secretNamespacedName] = &secret
-		sut.gitlabClient = &MockGitlabClient{
-			newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
-				return &gitlab.Client{}, nil
-			},
-			listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-				groups := []*gitlab.Group{&gitlab.Group{
-					ID:                             0,
-					Name:                           "",
-					Path:                           "",
-					Description:                    "",
-					MembershipLock:                 false,
-					Visibility:                     "",
-					LFSEnabled:                     false,
-					AvatarURL:                      "",
-					WebURL:                         "",
-					RequestAccessEnabled:           false,
-					FullName:                       "",
-					FullPath:                       "",
-					ParentID:                       0,
-					Projects:                       nil,
-					Statistics:                     nil,
-					CustomAttributes:               nil,
-					ShareWithGroupLock:             false,
-					RequireTwoFactorAuth:           false,
-					TwoFactorGracePeriod:           0,
-					ProjectCreationLevel:           "",
-					AutoDevopsEnabled:              false,
-					SubGroupCreationLevel:          "",
-					EmailsDisabled:                 false,
-					MentionsDisabled:               false,
-					RunnersToken:                   "",
-					SharedProjects:                 nil,
-					SharedWithGroups:               nil,
-					LDAPCN:                         "",
-					LDAPAccess:                     0,
-					LDAPGroupLinks:                 nil,
-					SharedRunnersMinutesLimit:      0,
-					ExtraSharedRunnersMinutesLimit: 0,
-					MarkedForDeletionOn:            nil,
-					CreatedAt:                      nil,
-				}}
-				return groups, &gitlab.Response{
-					Response: &http.Response{
-						Status:           "",
-						StatusCode:       0,
-						Proto:            "",
-						ProtoMajor:       0,
-						ProtoMinor:       0,
-						Header:           nil,
-						Body:             nil,
-						ContentLength:    0,
-						TransferEncoding: nil,
-						Close:            false,
-						Uncompressed:     false,
-						Trailer:          nil,
-						Request:          nil,
-						TLS:              nil,
-					},
-					TotalItems:   0,
-					TotalPages:   0,
-					ItemsPerPage: 0,
-					CurrentPage:  0,
-					NextPage:     0,
-					PreviousPage: 0,
-				}, nil
-			},
-			createGroupFunction: func(name string, description string) (*gitlab.Group, *gitlab.Response, error) {
-				return nil, &gitlab.Response{}, &MockError{
-					message: "Error",
-				}
-			},
-		}
-		result, err := sut.Reconcile(contextMock, requestMock)
-		It("should requeue the object", func() {
-			Expect(result).To(Equal(ctrl.Result{Requeue: true}))
-		})
-		It("should log the error", func() {
-			Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-			Expect(loggerMock.loggedMessage).To(Equal(errorWhileCreatingGitlabGroup))
-		})
-		It("should return an error", func() {
-			Expect(err).NotTo(BeNil())
-		})
-	})
-})
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("updateGroup fails", func() {
-		loggerMock := &MockLogger{
-			WithValuesKeysAndValues: nil,
-			WithValuesCalled:        false,
-			WithNameValue:           "",
-			WithNameCalled:          false,
-		}
-		contextMock := context.TODO()
-		clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-			return nil
-		}}}
-		requestMock := ctrl.Request{}
-		sut := GroupReconciler{
-			Client: &clientMock,
-			Log:    loggerMock,
-			Scheme: scheme,
-		}
-		requestMock.NamespacedName = types.NamespacedName{
-			Namespace: "default",
-			Name:      "testGroup",
-		}
-		gitlabCred := gitlabv1alpha1.GitlabCredentials{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GitlabCredentialsSpec{
-				URL:      "https://example.com",
-				Username: "ausername",
-				AccessToken: v1.SecretReference{
-					Name:      "asecret",
-					Namespace: "default",
-				},
-			},
-			Status: gitlabv1alpha1.GitlabCredentialsStatus{},
-		}
-		group := gitlabv1alpha1.Group{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GroupSpec{
-				Name:                  "agroup",
-				GitlabCredentialsName: "gitlab-credentials",
-				ProjectSpecs:          nil,
-			},
-			Status: gitlabv1alpha1.GroupStatus{},
-		}
-		secretNamespacedName := types.NamespacedName{
-			Namespace: gitlabCred.Spec.AccessToken.Namespace,
-			Name:      gitlabCred.Spec.AccessToken.Name,
-		}
-		stringData := map[string]string{"accessToken": "password"}
-		secret := v1.Secret{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			StringData: stringData,
-			Type:       "opaque",
-		}
-		clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-		clientMock.expectedObjects[requestMock.NamespacedName] = &group
-		clientMock.expectedObjects[types.NamespacedName{
-			Namespace: "default",
-			Name:      group.Spec.GitlabCredentialsName,
-		}] = &gitlabCred
-		clientMock.expectedObjects[secretNamespacedName] = &secret
-		sut.gitlabClient = &MockGitlabClient{
-			newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
-				return &gitlab.Client{}, nil
-			},
-			listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-				groups := []*gitlab.Group{{Name: "agroup"}}
-				return groups, &gitlab.Response{
-					Response: &http.Response{
-						Status:           "",
-						StatusCode:       0,
-						Proto:            "",
-						ProtoMajor:       0,
-						ProtoMinor:       0,
-						Header:           nil,
-						Body:             nil,
-						ContentLength:    0,
-						TransferEncoding: nil,
-						Close:            false,
-						Uncompressed:     false,
-						Trailer:          nil,
-						Request:          nil,
-						TLS:              nil,
-					},
-					TotalItems:   0,
-					TotalPages:   0,
-					ItemsPerPage: 0,
-					CurrentPage:  0,
-					NextPage:     0,
-					PreviousPage: 0,
-				}, nil
-			},
-			updateGroupFunction: func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
-				return nil, &gitlab.Response{}, &MockError{
-					message: "Error",
-				}
-			},
-		}
-		result, err := sut.Reconcile(contextMock, requestMock)
-		It("should requeue the object", func() {
-			Expect(result).To(Equal(ctrl.Result{Requeue: true}))
-		})
-		It("should log the error", func() {
-			Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-			Expect(loggerMock.loggedMessage).To(Equal(errorWhileUpdatingGitlabGroup))
-		})
-		It("should return an error", func() {
-			Expect(err).NotTo(BeNil())
-		})
-	})
-})
-
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("updateStatus fails", func() {
-		loggerMock := &MockLogger{
-			WithValuesKeysAndValues: nil,
-			WithValuesCalled:        false,
-			WithNameValue:           "",
-			WithNameCalled:          false,
-		}
-		contextMock := context.TODO()
-		clientMock := MockClient{
-			statusWriter: &MockStatusWriter{
-				updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-					return &MockError{"error"}
-				},
-			},
-		}
-		requestMock := ctrl.Request{}
-		sut := GroupReconciler{
-			Client: &clientMock,
-			Log:    loggerMock,
-			Scheme: scheme,
-		}
-		requestMock.NamespacedName = types.NamespacedName{
-			Namespace: "default",
-			Name:      "testGroup",
-		}
-		gitlabCred := gitlabv1alpha1.GitlabCredentials{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GitlabCredentialsSpec{
-				URL:      "https://example.com",
-				Username: "ausername",
-				AccessToken: v1.SecretReference{
-					Name:      "asecret",
-					Namespace: "default",
-				},
-			},
-			Status: gitlabv1alpha1.GitlabCredentialsStatus{},
-		}
-		group := gitlabv1alpha1.Group{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GroupSpec{
-				Name:                  "agroup",
-				GitlabCredentialsName: "gitlab-credentials",
-				ProjectSpecs:          nil,
-			},
-			Status: gitlabv1alpha1.GroupStatus{},
-		}
-		secretNamespacedName := types.NamespacedName{
-			Namespace: gitlabCred.Spec.AccessToken.Namespace,
-			Name:      gitlabCred.Spec.AccessToken.Name,
-		}
-		stringData := map[string]string{"accessToken": "password"}
-		secret := v1.Secret{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			StringData: stringData,
-			Type:       "opaque",
-		}
-		clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-		clientMock.expectedObjects[requestMock.NamespacedName] = &group
-		clientMock.expectedObjects[types.NamespacedName{
-			Namespace: "default",
-			Name:      group.Spec.GitlabCredentialsName,
-		}] = &gitlabCred
-		clientMock.expectedObjects[secretNamespacedName] = &secret
-		sut.gitlabClient = &MockGitlabClient{
-			newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
-				return &gitlab.Client{}, nil
-			},
-			listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-				groups := []*gitlab.Group{{Name: "agroup"}}
-				return groups, &gitlab.Response{
-					Response: &http.Response{
-						Status:           "",
-						StatusCode:       0,
-						Proto:            "",
-						ProtoMajor:       0,
-						ProtoMinor:       0,
-						Header:           nil,
-						Body:             nil,
-						ContentLength:    0,
-						TransferEncoding: nil,
-						Close:            false,
-						Uncompressed:     false,
-						Trailer:          nil,
-						Request:          nil,
-						TLS:              nil,
-					},
-					TotalItems:   0,
-					TotalPages:   0,
-					ItemsPerPage: 0,
-					CurrentPage:  0,
-					NextPage:     0,
-					PreviousPage: 0,
-				}, nil
-			},
-			updateGroupFunction: func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
-				return &gitlab.Group{Name: "agroup"}, &gitlab.Response{}, nil
-			},
-		}
-		result, err := sut.Reconcile(contextMock, requestMock)
-		It("should requeue the object", func() {
-			Expect(result).To(Equal(ctrl.Result{Requeue: true}))
-		})
-		It("should log the error", func() {
-			Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-			Expect(loggerMock.loggedMessage).To(Equal(errorUnableToUpdateStatus))
-		})
-		It("should return an error", func() {
-			Expect(err).NotTo(BeNil())
-		})
-	})
-})
-
-var _ = Describe("Reconcile", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	When("processProjects fails", func() {
-		loggerMock := &MockLogger{
-			WithValuesKeysAndValues: nil,
-			WithValuesCalled:        false,
-			WithNameValue:           "",
-			WithNameCalled:          false,
-		}
-		contextMock := context.TODO()
-		clientMock := MockClient{
-			statusWriter: &MockStatusWriter{
-				updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-					return nil
-				},
-			},
-			createFunction: func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
-				return &MockError{message: "error"}
-			},
-		}
-		requestMock := ctrl.Request{}
-		sut := GroupReconciler{
-			Client: &clientMock,
-			Log:    loggerMock,
-			Scheme: scheme,
-		}
-		requestMock.NamespacedName = types.NamespacedName{
-			Namespace: "default",
-			Name:      "testGroup",
-		}
-		gitlabCred := gitlabv1alpha1.GitlabCredentials{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GitlabCredentialsSpec{
-				URL:      "https://example.com",
-				Username: "ausername",
-				AccessToken: v1.SecretReference{
-					Name:      "asecret",
-					Namespace: "default",
-				},
-			},
-			Status: gitlabv1alpha1.GitlabCredentialsStatus{},
-		}
-		group := gitlabv1alpha1.Group{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			Spec: gitlabv1alpha1.GroupSpec{
-				Name:                  "agroup",
-				GitlabCredentialsName: "gitlab-credentials",
-				ProjectSpecs:          []gitlabv1alpha1.ProjectSpec{{Name: "ProjectSpec"}},
-			},
-			Status: gitlabv1alpha1.GroupStatus{},
-		}
-		secretNamespacedName := types.NamespacedName{
-			Namespace: gitlabCred.Spec.AccessToken.Namespace,
-			Name:      gitlabCred.Spec.AccessToken.Name,
-		}
-		stringData := map[string]string{"accessToken": "password"}
-		secret := v1.Secret{
-			TypeMeta:   metav1.TypeMeta{},
-			ObjectMeta: metav1.ObjectMeta{},
-			StringData: stringData,
-			Type:       "opaque",
-		}
-		clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
-		clientMock.expectedObjects[requestMock.NamespacedName] = &group
-		clientMock.expectedObjects[types.NamespacedName{
-			Namespace: "default",
-			Name:      group.Spec.GitlabCredentialsName,
-		}] = &gitlabCred
-		clientMock.expectedObjects[secretNamespacedName] = &secret
-		sut.gitlabClient = &MockGitlabClient{
-			newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
-				return &gitlab.Client{}, nil
-			},
-			listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-				groups := []*gitlab.Group{{Name: "agroup"}}
-				return groups, &gitlab.Response{
-					Response: &http.Response{
-						Status:           "",
-						StatusCode:       0,
-						Proto:            "",
-						ProtoMajor:       0,
-						ProtoMinor:       0,
-						Header:           nil,
-						Body:             nil,
-						ContentLength:    0,
-						TransferEncoding: nil,
-						Close:            false,
-						Uncompressed:     false,
-						Trailer:          nil,
-						Request:          nil,
-						TLS:              nil,
-					},
-					TotalItems:   0,
-					TotalPages:   0,
-					ItemsPerPage: 0,
-					CurrentPage:  0,
-					NextPage:     0,
-					PreviousPage: 0,
-				}, nil
-			},
-			updateGroupFunction: func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
-				return &gitlab.Group{Name: "agroup"}, &gitlab.Response{}, nil
-			},
-		}
-		result, err := sut.Reconcile(contextMock, requestMock)
-		It("should requeue the object", func() {
-			Expect(result).To(Equal(ctrl.Result{Requeue: true}))
-		})
-		It("should log the error", func() {
-			Expect(loggerMock.logLevelCalled).To(Equal("Error"))
-			Expect(loggerMock.loggedMessage).To(Equal(errorUnableToProcessProjects))
-		})
-		It("should return an error", func() {
-			Expect(err).NotTo(BeNil())
-		})
-	})
-})
-
-var _ = Describe("groupExists", func() {
-	When("the gitlab client fails", func() {
-		sut := GroupReconciler{
-			gitlabClient: &MockGitlabClient{
-				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-					return nil, &gitlab.Response{}, &MockError{
-						message: "mockedError",
-					}
-				},
-			},
-		}
-		found, response, groups, err := sut.groupExists(&gitlabv1alpha1.Group{Spec: gitlabv1alpha1.GroupSpec{Name: "An error"}})
-		It("should return that it didn't find the group", func() {
-			Expect(found).To(Equal(false))
-		})
-		It("should return the gitlab response", func() {
-			Expect(response).ToNot(BeNil())
-		})
-		It("should return a nil group", func() {
-			Expect(groups).To(BeNil())
-		})
-		It("should return an error", func() {
-			Expect(err).ToNot(BeNil())
-		})
-	})
-	When("the group is in the list", func() {
-		group := &gitlab.Group{Name: "A group"}
-		returnGroups := []*gitlab.Group{group}
-		sut := GroupReconciler{
-			gitlabClient: &MockGitlabClient{
-				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-					return returnGroups, &gitlab.Response{}, nil
-				},
-			},
-		}
-
-		found, response, returnedGroup, err := sut.groupExists(&gitlabv1alpha1.Group{Spec: gitlabv1alpha1.GroupSpec{Name: "A group"}})
-		It("should return that it found the group", func() {
-			Expect(found).To(Equal(true))
-		})
-		It("should return the gitlab response", func() {
-			Expect(response).ToNot(BeNil())
-		})
-		It("should return list with the group", func() {
-			Expect(returnedGroup).To(Equal(group))
-		})
-		It("should not return an error", func() {
-			Expect(err).To(BeNil())
-		})
-	})
-	When("the group is not in the list", func() {
-		sut := GroupReconciler{
-			gitlabClient: &MockGitlabClient{
-				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-					return nil, &gitlab.Response{}, nil
-				},
-			},
-		}
-
-		found, response, groups, err := sut.groupExists(&gitlabv1alpha1.Group{Spec: gitlabv1alpha1.GroupSpec{Name: "A group"}})
-		It("should return that it did not find the group", func() {
-			Expect(found).To(Equal(false))
-		})
-		It("should return the gitlab response", func() {
-			Expect(response).ToNot(BeNil())
-		})
-		It("should return nil for the group list", func() {
-			Expect(groups).To(BeNil())
-		})
-		It("should not return an error", func() {
-			Expect(err).To(BeNil())
-		})
-	})
-})
-var _ = Describe("createGroup", func() {
-	expectedGroup := &gitlab.Group{ID: 1, Name: "A test group"}
-	expectedResponse := &gitlab.Response{
-		Response:     &http.Response{},
-		TotalItems:   1,
-		TotalPages:   1,
-		ItemsPerPage: 10,
-		CurrentPage:  1,
-		NextPage:     0,
-		PreviousPage: 0,
-	}
-	sut := GroupReconciler{
-		gitlabClient: &MockGitlabClient{
-			createGroupFunction: func(name string, description string) (*gitlab.Group, *gitlab.Response, error) {
-				return expectedGroup, expectedResponse, nil
-			},
-		},
-	}
-	group, response, err := sut.createGroup(
-		&gitlabv1alpha1.Group{
-			ObjectMeta: ctrl.ObjectMeta{Annotations: make(map[string]string)},
-			Spec:       gitlabv1alpha1.GroupSpec{Name: "a group"},
-		})
-	It("should return the gitlab group created", func() {
-		Expect(group).To(Equal(expectedGroup))
-	})
-	It("should return the gitlab response", func() {
-		Expect(response).To(Equal(expectedResponse))
-	})
-	It("should return the error created by the call, or nil", func() {
-		Expect(err).To(BeNil())
-	})
-})
-
-var _ = Describe("updateGroup", func() {
-	expectedGroup := &gitlab.Group{ID: 2, Name: "A test group"}
-	expectedResponse := &gitlab.Response{
-		Response:     &http.Response{},
-		TotalItems:   1,
-		TotalPages:   1,
-		ItemsPerPage: 10,
-		CurrentPage:  1,
-		NextPage:     0,
-		PreviousPage: 0,
-	}
-	sut := GroupReconciler{
-		gitlabClient: &MockGitlabClient{
-			updateGroupFunction: func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
-				return expectedGroup, expectedResponse, nil
-			},
-			listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-				return []*gitlab.Group{{Name: "a group"}}, &gitlab.Response{}, nil
-			},
-		},
-	}
-	group, response, err := sut.updateGroup(
-		&gitlabv1alpha1.Group{
-			ObjectMeta: ctrl.ObjectMeta{Annotations: make(map[string]string)},
-			Spec:       gitlabv1alpha1.GroupSpec{Name: "a group"},
-			Status: gitlabv1alpha1.GroupStatus{
-				GitlabID:        nil,
-				CreatedTime:     metav1.Time{},
-				LastUpdatedTime: metav1.Time{},
-				State:           "",
-			},
-		})
-	It("should return the gitlab group created", func() {
-		Expect(group).To(Equal(expectedGroup))
-	})
-	It("should return the gitlab response", func() {
-		Expect(response).To(Equal(expectedResponse))
-	})
-	It("should return the error created by the call, or nil", func() {
-		Expect(err).To(BeNil())
-	})
-})
-
-var _ = Describe("SetupWithManager", func() {
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	loggerMock := MockLogger{
-		WithValuesKeysAndValues: nil,
-		WithValuesCalled:        false,
-		WithNameValue:           "",
-		WithNameCalled:          false,
-	}
-	clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-		return nil
-	}}}
-	sut := GroupReconciler{
-		Client: &clientMock,
-		Log:    &loggerMock,
-		Scheme: scheme,
-	}
-	err := sut.SetupWithManager(&MockManager{
-		Log:     &loggerMock,
-		builder: builder,
-	})
-	It("should setup the default gitlab client", func() {
-		Expect(sut.gitlabClient).To(BeAssignableToTypeOf(&ClientImpl{}))
-	})
-	It("should return no error", func() {
-		Expect(err).To(BeNil())
-	})
-})
-
-var _ = Describe("updateStatus", func() {
-	When("group id is not 0", func() {
-		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-		scheme, _ := builder.Build()
-		loggerMock := MockLogger{
-			WithValuesKeysAndValues: nil,
-			WithValuesCalled:        false,
-			WithNameValue:           "",
-			WithNameCalled:          false,
-		}
-		clientMock := MockClient{statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-			return nil
-		}}}
-		sut := GroupReconciler{
-			Client: &clientMock,
-			Log:    &loggerMock,
-			Scheme: scheme,
-		}
-		group := gitlabv1alpha1.Group{Status: gitlabv1alpha1.GroupStatus{
-			GitlabID:        nil,
-			CreatedTime:     metav1.Time{},
-			LastUpdatedTime: metav1.Time{},
-			State:           "",
-		}}
-		sut.updateStatus(&MockContext{}, 1, &group)
-
-		It("should update the gitlab id", func() {
-			Expect(*group.Status.GitlabID).To(Equal(int64(1)))
-		})
-		It("should update the last updated time", func() {
-			Expect(group.Status.LastUpdatedTime.Time).To(Not(BeNil()))
-		})
-	})
-})
-
-var _ = Describe("updateProject", func() {
-	spec := gitlabv1alpha1.ProjectSpec{
-		Name:           "a project",
-		Path:           "https://example.com.path",
-		ImpactLevel:    "2",
-		StorageTypes:   nil,
-		VirtualService: "default",
-		ServicePort:    8081,
-		Language:       "golang",
-	}
-	project := gitlabv1alpha1.Project{Spec: gitlabv1alpha1.ProjectSpec{}}
-	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
-	scheme, _ := builder.Build()
-	loggerMock := MockLogger{
-		WithValuesKeysAndValues: nil,
-		WithValuesCalled:        false,
-		WithNameValue:           "",
-		WithNameCalled:          false,
-	}
-	mockError := &MockError{"true"}
-	clientMock := MockClient{
-		statusWriter: MockStatusWriter{
-			updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-				return nil
-			},
-		},
-		updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-			return mockError
-		},
-	}
-	sut := GroupReconciler{
-		Client: &clientMock,
-		Log:    &loggerMock,
-		Scheme: scheme,
-	}
-
-	returnedProject, err := sut.updateProject(context.TODO(), spec, &project)
-	It("should update the project from the project specification", func() {
-		Expect(project.Spec.Name).To(Equal(spec.Name))
-		Expect(project.Spec.ServicePort).To(Equal(spec.ServicePort))
-		Expect(project.Spec.Language).To(Equal(spec.Language))
-		Expect(project.Spec.Path).To(Equal(spec.Path))
-		Expect(project.Spec.VirtualService).To(Equal(spec.VirtualService))
-		Expect(project.Spec.StorageTypes).To(Equal(spec.StorageTypes))
-		Expect(project.Spec.ImpactLevel).To(Equal(spec.ImpactLevel))
-	})
-	It("should call the kubernetes client update function", func() {
-		Expect(clientMock.updateFunctionCalled).To(BeTrue())
-	})
-	It("should return the result of the update function", func() {
-		Expect(err).To(Equal(mockError))
-	})
-	It("should return the updated project", func() {
-		Expect(project).To(Equal(*returnedProject))
-	})
-})
+package gitlab
+
+import (
+	"context"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/xanzy/go-gitlab"
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"net/http"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	gitlabv1alpha1 "valkyrie.dso.mil/valkyrie-api/apis/gitlab/v1alpha1"
+)
+
+
+var _ =
+	Describe("Reconcile", func() {
+	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+	scheme, _ := builder.Build()
+	When("it looks up the API Object", func() {
+		Context("the API Object isn't found", func() {
+			loggerMock := MockLogger{
+				WithValuesKeysAndValues: nil,
+				WithValuesCalled:        false,
+				WithNameValue:           "",
+				WithNameCalled:          false,
+			}
+			contextMock := context.TODO()
+			clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+					return nil
+				}}}
+			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+			requestMock := ctrl.Request{}
+			sut := GroupReconciler{
+				Client: &clientMock,
+				Log:    &loggerMock,
+				Scheme: scheme,
+			}
+			result, err := sut.Reconcile(contextMock, requestMock)
+			It("should log the error", func() {
+				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+				Expect(loggerMock.loggedMessage).To(Equal("unable to fetch group"))
+			})
+			It("should return an empty result, and ignore the error.", func() {
+				Expect(result).Should(Equal(ctrl.Result{}))
+				Expect(err).Should(BeNil())
+			})
+		})
+	})
+})
+var _ =
+	Describe("Reconcile", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		When("it looks up the GitlabCredentals", func() {
+			Context("gitlab credentials are not found", func() {
+				loggerMock := MockLogger{
+					WithValuesKeysAndValues: nil,
+					WithValuesCalled:        false,
+					WithNameValue:           "",
+					WithNameCalled:          false,
+				}
+				contextMock := context.TODO()
+				clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+					return nil
+				}}}
+				requestMock := ctrl.Request{}
+				sut := GroupReconciler{
+					Client: &clientMock,
+					Log:    &loggerMock,
+					Scheme: scheme,
+				}
+				requestMock.NamespacedName = types.NamespacedName{
+					Namespace: "default",
+					Name:      "testGroup",
+				}
+				clientMock.GetFunction = nil
+				group := gitlabv1alpha1.Group{
+					TypeMeta:   metav1.TypeMeta{},
+					ObjectMeta: metav1.ObjectMeta{},
+					Spec:       gitlabv1alpha1.GroupSpec{},
+					Status:     gitlabv1alpha1.GroupStatus{},
+				}
+				clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+				clientMock.expectedObjects[requestMock.NamespacedName] = &group
+				result, err := sut.Reconcile(contextMock, requestMock)
+				It("should log the error", func() {
+					Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+					Expect(loggerMock.loggedMessage).To(Equal("unable to fetch gitlab credentials"))
+				})
+				It("should return a reconcile result, and the error.", func() {
+					Expect(result).To(Equal(ctrl.Result{
+						Requeue: true,
+					}))
+					Expect(err).ToNot(BeNil())
+				})
+			})
+		})
+	})
+var _ =
+	Describe("Reconcile", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		When("getting the secret from the GitlabCredentials", func() {
+			Context("Secret doesn't exist", func() {
+				loggerMock := MockLogger{
+					WithValuesKeysAndValues: nil,
+					WithValuesCalled:        false,
+					WithNameValue:           "",
+					WithNameCalled:          false,
+				}
+				contextMock := context.TODO()
+				clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+					return nil
+				}}}
+				requestMock := ctrl.Request{}
+				sut := GroupReconciler{
+					Client: &clientMock,
+					Log:    &loggerMock,
+					Scheme: scheme,
+				}
+				requestMock.NamespacedName = types.NamespacedName{
+					Namespace: "default",
+					Name:      "testGroup",
+				}
+				gitlabCred := gitlabv1alpha1.GitlabCredentials{
+					TypeMeta:   metav1.TypeMeta{},
+					ObjectMeta: metav1.ObjectMeta{},
+					Spec: gitlabv1alpha1.GitlabCredentialsSpec{
+						URL:      "https://example.com",
+						Username: "ausername",
+						AccessToken: v1.SecretReference{
+							Name:      "asecret",
+							Namespace: "default",
+						},
+					},
+					Status: gitlabv1alpha1.GitlabCredentialsStatus{},
+				}
+				group := gitlabv1alpha1.Group{
+					TypeMeta:   metav1.TypeMeta{},
+					ObjectMeta: metav1.ObjectMeta{},
+					Spec: gitlabv1alpha1.GroupSpec{
+						Name:                  "agroup",
+						GitlabCredentialsName: "gitlab-credentials",
+						ProjectSpecs:          nil,
+					},
+					Status: gitlabv1alpha1.GroupStatus{},
+				}
+
+				clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+				clientMock.expectedObjects[requestMock.NamespacedName] = &group
+				clientMock.expectedObjects[types.NamespacedName{
+					Namespace: "default",
+					Name:      group.Spec.GitlabCredentialsName,
+				}] = &gitlabCred
+				result, err := sut.Reconcile(contextMock, requestMock)
+				It("Should log an error regarding the missing credentials", func() {
+					Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+					Expect(loggerMock.loggedMessage).To(Equal("unable to fetch secret from gitlab credentials"))
+				})
+				It("Should return a requeue result and an error", func() {
+					Expect(result).To(Equal(ctrl.Result{Requeue: true}))
+					Expect(err).ToNot(BeNil())
+				})
+			})
+		})
+	})
+var _ =
+	Describe("Reconcile", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		When("logging in to GitLab", func() {
+			Context("can't create client", func() {
+				loggerMock := &MockLogger{
+					WithValuesKeysAndValues: nil,
+					WithValuesCalled:        false,
+					WithNameValue:           "",
+					WithNameCalled:          false,
+				}
+				contextMock := context.TODO()
+				clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+					return nil
+				}}}
+				requestMock := ctrl.Request{}
+				sut := GroupReconciler{
+					Client: &clientMock,
+					Log:    loggerMock,
+					Scheme: scheme,
+				}
+				requestMock.NamespacedName = types.NamespacedName{
+					Namespace: "default",
+					Name:      "testGroup",
+				}
+				gitlabCred := gitlabv1alpha1.GitlabCredentials{
+					TypeMeta:   metav1.TypeMeta{},
+					ObjectMeta: metav1.ObjectMeta{},
+					Spec: gitlabv1alpha1.GitlabCredentialsSpec{
+						URL:      "https://example.com",
+						Username: "ausername",
+						AccessToken: v1.SecretReference{
+							Name:      "asecret",
+							Namespace: "default",
+						},
+					},
+					Status: gitlabv1alpha1.GitlabCredentialsStatus{},
+				}
+				group := gitlabv1alpha1.Group{
+					TypeMeta:   metav1.TypeMeta{},
+					ObjectMeta: metav1.ObjectMeta{},
+					Spec: gitlabv1alpha1.GroupSpec{
+						Name:                  "agroup",
+						GitlabCredentialsName: "gitlab-credentials",
+						ProjectSpecs:          nil,
+					},
+					Status: gitlabv1alpha1.GroupStatus{},
+				}
+				secretNamespacedName := types.NamespacedName{
+					Namespace: gitlabCred.Spec.AccessToken.Namespace,
+					Name:      gitlabCred.Spec.AccessToken.Name,
+				}
+				stringData := map[string]string { "accessToken" : "password"}
+				secret := v1.Secret{
+					TypeMeta:   metav1.TypeMeta{},
+					ObjectMeta: metav1.ObjectMeta{},
+					StringData: stringData,
+					Type:       "opaque",
+				}
+				clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+				clientMock.expectedObjects[requestMock.NamespacedName] = &group
+				clientMock.expectedObjects[types.NamespacedName{
+					Namespace: "default",
+					Name:      group.Spec.GitlabCredentialsName,
+				}] = &gitlabCred
+				clientMock.expectedObjects[secretNamespacedName] = &secret
+				sut.gitlabClient = &MockGitlabClient{
+					newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
+						return nil, &MockError{
+							message: "mocked error",
+						}
+					},
+				}
+				result, err := sut.Reconcile(contextMock, requestMock)
+				It("Should log the failure", func() {
+					Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+					Expect(loggerMock.loggedMessage).To(Equal(errorUnableToCreateGitlabClient))
+				})
+				It("Should return an error", func() {
+					Expect(err).ToNot(BeNil())
+				})
+				It("should requeue the group", func() {
+					Expect(result).To(Equal(ctrl.Result{Requeue: true}))
+				})
+			})
+		})
+	})
+
+var _ =
+	Describe("Reconcile", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		When("groupExists fails", func() {
+			loggerMock := &MockLogger{
+				WithValuesKeysAndValues: nil,
+				WithValuesCalled:        false,
+				WithNameValue:           "",
+				WithNameCalled:          false,
+			}
+			contextMock := context.TODO()
+			clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+					return nil
+				}}}
+			requestMock := ctrl.Request{}
+			sut := GroupReconciler{
+				Client: &clientMock,
+				Log:    loggerMock,
+				Scheme: scheme,
+			}
+			requestMock.NamespacedName = types.NamespacedName{
+				Namespace: "default",
+				Name:      "testGroup",
+			}
+			gitlabCred := gitlabv1alpha1.GitlabCredentials{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GitlabCredentialsSpec{
+					URL:      "https://example.com",
+					Username: "ausername",
+					AccessToken: v1.SecretReference{
+						Name:      "asecret",
+						Namespace: "default",
+					},
+				},
+				Status: gitlabv1alpha1.GitlabCredentialsStatus{},
+			}
+			group := gitlabv1alpha1.Group{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GroupSpec{
+					Name:                  "agroup",
+					GitlabCredentialsName: "gitlab-credentials",
+					ProjectSpecs:          nil,
+				},
+				Status: gitlabv1alpha1.GroupStatus{},
+			}
+			secretNamespacedName := types.NamespacedName{
+				Namespace: gitlabCred.Spec.AccessToken.Namespace,
+				Name:      gitlabCred.Spec.AccessToken.Name,
+			}
+			stringData := map[string]string { "accessToken" : "password"}
+			secret := v1.Secret{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				StringData: stringData,
+				Type:       "opaque",
+			}
+			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+			clientMock.expectedObjects[requestMock.NamespacedName] = &group
+			clientMock.expectedObjects[types.NamespacedName{
+				Namespace: "default",
+				Name:      group.Spec.GitlabCredentialsName,
+			}] = &gitlabCred
+			clientMock.expectedObjects[secretNamespacedName] = &secret
+			sut.gitlabClient = &MockGitlabClient{
+				newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
+					return &gitlab.Client{}, nil
+				},
+				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+					return nil, &gitlab.Response{
+							Response:     &http.Response{
+								Status:           "",
+								StatusCode:       0,
+								Proto:            "",
+								ProtoMajor:       0,
+								ProtoMinor:       0,
+								Header:           nil,
+								Body:             nil,
+								ContentLength:    0,
+								TransferEncoding: nil,
+								Close:            false,
+								Uncompressed:     false,
+								Trailer:          nil,
+								Request:          nil,
+								TLS:              nil,
+							},
+							TotalItems:   0,
+							TotalPages:   0,
+							ItemsPerPage: 0,
+							CurrentPage:  0,
+							NextPage:     0,
+							PreviousPage: 0,
+						}, &MockError{
+						message: "Error",
+					}
+				},
+			}
+			result, err := sut.Reconcile(contextMock, requestMock)
+			It("should requeue the object", func() {
+				Expect(result).To(Equal(ctrl.Result{Requeue: true}))
+			})
+			It("should log the error", func() {
+				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+				Expect(loggerMock.loggedMessage).To(Equal(errorWhileSearchingGroups))
+			})
+			It("should return an error", func() {
+				Expect(err).NotTo(BeNil())
+			})
+		})
+	})
+
+var _ =
+	Describe("Reconcile", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		When("createGroup fails", func() {
+			loggerMock := &MockLogger{
+				WithValuesKeysAndValues: nil,
+				WithValuesCalled:        false,
+				WithNameValue:           "",
+				WithNameCalled:          false,
+			}
+			contextMock := context.TODO()
+			clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+					return nil
+				}}}
+			requestMock := ctrl.Request{}
+			sut := GroupReconciler{
+				Client: &clientMock,
+				Log:    loggerMock,
+				Scheme: scheme,
+			}
+			requestMock.NamespacedName = types.NamespacedName{
+				Namespace: "default",
+				Name:      "testGroup",
+			}
+			gitlabCred := gitlabv1alpha1.GitlabCredentials{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GitlabCredentialsSpec{
+					URL:      "https://example.com",
+					Username: "ausername",
+					AccessToken: v1.SecretReference{
+						Name:      "asecret",
+						Namespace: "default",
+					},
+				},
+				Status: gitlabv1alpha1.GitlabCredentialsStatus{},
+			}
+			group := gitlabv1alpha1.Group{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GroupSpec{
+					Name:                  "agroup",
+					GitlabCredentialsName: "gitlab-credentials",
+					ProjectSpecs:          nil,
+				},
+				Status: gitlabv1alpha1.GroupStatus{},
+			}
+			secretNamespacedName := types.NamespacedName{
+				Namespace: gitlabCred.Spec.AccessToken.Namespace,
+				Name:      gitlabCred.Spec.AccessToken.Name,
+			}
+			stringData := map[string]string { "accessToken" : "password"}
+			secret := v1.Secret{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				StringData: stringData,
+				Type:       "opaque",
+			}
+			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+			clientMock.expectedObjects[requestMock.NamespacedName] = &group
+			clientMock.expectedObjects[types.NamespacedName{
+				Namespace: "default",
+				Name:      group.Spec.GitlabCredentialsName,
+			}] = &gitlabCred
+			clientMock.expectedObjects[secretNamespacedName] = &secret
+			sut.gitlabClient = &MockGitlabClient{
+				newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
+					return &gitlab.Client{}, nil
+				},
+				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+					groups := []*gitlab.Group{ &gitlab.Group{
+						ID:                             0,
+						Name:                           "",
+						Path:                           "",
+						Description:                    "",
+						MembershipLock:                 false,
+						Visibility:                     "",
+						LFSEnabled:                     false,
+						AvatarURL:                      "",
+						WebURL:                         "",
+						RequestAccessEnabled:           false,
+						FullName:                       "",
+						FullPath:                       "",
+						ParentID:                       0,
+						Projects:                       nil,
+						Statistics:                     nil,
+						CustomAttributes:               nil,
+						ShareWithGroupLock:             false,
+						RequireTwoFactorAuth:           false,
+						TwoFactorGracePeriod:           0,
+						ProjectCreationLevel:           "",
+						AutoDevopsEnabled:              false,
+						SubGroupCreationLevel:          "",
+						EmailsDisabled:                 false,
+						MentionsDisabled:               false,
+						RunnersToken:                   "",
+						SharedProjects:                 nil,
+						SharedWithGroups:               nil,
+						LDAPCN:                         "",
+						LDAPAccess:                     0,
+						LDAPGroupLinks:                 nil,
+						SharedRunnersMinutesLimit:      0,
+						ExtraSharedRunnersMinutesLimit: 0,
+						MarkedForDeletionOn:            nil,
+						CreatedAt:                      nil,
+					} }
+					return groups, &gitlab.Response{
+							Response:     &http.Response{
+								Status:           "",
+								StatusCode:       0,
+								Proto:            "",
+								ProtoMajor:       0,
+								ProtoMinor:       0,
+								Header:           nil,
+								Body:             nil,
+								ContentLength:    0,
+								TransferEncoding: nil,
+								Close:            false,
+								Uncompressed:     false,
+								Trailer:          nil,
+								Request:          nil,
+								TLS:              nil,
+							},
+							TotalItems:   0,
+							TotalPages:   0,
+							ItemsPerPage: 0,
+							CurrentPage:  0,
+							NextPage:     0,
+							PreviousPage: 0,
+						}, nil
+				},
+				createGroupFunction: func(name string, description string) (*gitlab.Group, *gitlab.Response, error) {
+					return nil, &gitlab.Response{}, &MockError{
+						message: "Error",
+					}
+				},
+			}
+			result, err := sut.Reconcile(contextMock, requestMock)
+			It("should requeue the object", func() {
+				Expect(result).To(Equal(ctrl.Result{Requeue: true}))
+			})
+			It("should log the error", func() {
+				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+				Expect(loggerMock.loggedMessage).To(Equal(errorWhileCreatingGitlabGroup))
+			})
+			It("should return an error", func() {
+				Expect(err).NotTo(BeNil())
+			})
+		})
+	})
+var _ =
+	Describe("Reconcile", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		When("updateGroup fails", func() {
+			loggerMock := &MockLogger{
+				WithValuesKeysAndValues: nil,
+				WithValuesCalled:        false,
+				WithNameValue:           "",
+				WithNameCalled:          false,
+			}
+			contextMock := context.TODO()
+			clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+					return nil
+				}}}
+			requestMock := ctrl.Request{}
+			sut := GroupReconciler{
+				Client: &clientMock,
+				Log:    loggerMock,
+				Scheme: scheme,
+			}
+			requestMock.NamespacedName = types.NamespacedName{
+				Namespace: "default",
+				Name:      "testGroup",
+			}
+			gitlabCred := gitlabv1alpha1.GitlabCredentials{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GitlabCredentialsSpec{
+					URL:      "https://example.com",
+					Username: "ausername",
+					AccessToken: v1.SecretReference{
+						Name:      "asecret",
+						Namespace: "default",
+					},
+				},
+				Status: gitlabv1alpha1.GitlabCredentialsStatus{},
+			}
+			group := gitlabv1alpha1.Group{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GroupSpec{
+					Name:                  "agroup",
+					GitlabCredentialsName: "gitlab-credentials",
+					ProjectSpecs:          nil,
+				},
+				Status: gitlabv1alpha1.GroupStatus{},
+			}
+			secretNamespacedName := types.NamespacedName{
+				Namespace: gitlabCred.Spec.AccessToken.Namespace,
+				Name:      gitlabCred.Spec.AccessToken.Name,
+			}
+			stringData := map[string]string { "accessToken" : "password"}
+			secret := v1.Secret{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				StringData: stringData,
+				Type:       "opaque",
+			}
+			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+			clientMock.expectedObjects[requestMock.NamespacedName] = &group
+			clientMock.expectedObjects[types.NamespacedName{
+				Namespace: "default",
+				Name:      group.Spec.GitlabCredentialsName,
+			}] = &gitlabCred
+			clientMock.expectedObjects[secretNamespacedName] = &secret
+			sut.gitlabClient = &MockGitlabClient{
+				newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
+					return &gitlab.Client{}, nil
+				},
+				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+					groups := []*gitlab.Group{ {Name: "agroup"} }
+					return groups, &gitlab.Response{
+						Response:     &http.Response{
+							Status:           "",
+							StatusCode:       0,
+							Proto:            "",
+							ProtoMajor:       0,
+							ProtoMinor:       0,
+							Header:           nil,
+							Body:             nil,
+							ContentLength:    0,
+							TransferEncoding: nil,
+							Close:            false,
+							Uncompressed:     false,
+							Trailer:          nil,
+							Request:          nil,
+							TLS:              nil,
+						},
+						TotalItems:   0,
+						TotalPages:   0,
+						ItemsPerPage: 0,
+						CurrentPage:  0,
+						NextPage:     0,
+						PreviousPage: 0,
+					}, nil
+				},
+				updateGroupFunction: func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
+					return nil, &gitlab.Response{}, &MockError{
+						message: "Error",
+					}
+				},
+			}
+			result, err := sut.Reconcile(contextMock, requestMock)
+			It("should requeue the object", func() {
+				Expect(result).To(Equal(ctrl.Result{Requeue: true}))
+			})
+			It("should log the error", func() {
+				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+				Expect(loggerMock.loggedMessage).To(Equal(errorWhileUpdatingGitlabGroup))
+			})
+			It("should return an error", func() {
+				Expect(err).NotTo(BeNil())
+			})
+		})
+	})
+
+var _ =
+	Describe("Reconcile", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		When("updateStatus fails", func() {
+			loggerMock := &MockLogger{
+				WithValuesKeysAndValues: nil,
+				WithValuesCalled:        false,
+				WithNameValue:           "",
+				WithNameCalled:          false,
+			}
+			contextMock := context.TODO()
+			clientMock := MockClient{
+				statusWriter: &MockStatusWriter{
+					updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+						return &MockError{ "error"}
+					},
+				},
+			}
+			requestMock := ctrl.Request{}
+			sut := GroupReconciler{
+				Client: &clientMock,
+				Log:    loggerMock,
+				Scheme: scheme,
+			}
+			requestMock.NamespacedName = types.NamespacedName{
+				Namespace: "default",
+				Name:      "testGroup",
+			}
+			gitlabCred := gitlabv1alpha1.GitlabCredentials{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GitlabCredentialsSpec{
+					URL:      "https://example.com",
+					Username: "ausername",
+					AccessToken: v1.SecretReference{
+						Name:      "asecret",
+						Namespace: "default",
+					},
+				},
+				Status: gitlabv1alpha1.GitlabCredentialsStatus{},
+			}
+			group := gitlabv1alpha1.Group{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GroupSpec{
+					Name:                  "agroup",
+					GitlabCredentialsName: "gitlab-credentials",
+					ProjectSpecs:          nil,
+				},
+				Status: gitlabv1alpha1.GroupStatus{},
+			}
+			secretNamespacedName := types.NamespacedName{
+				Namespace: gitlabCred.Spec.AccessToken.Namespace,
+				Name:      gitlabCred.Spec.AccessToken.Name,
+			}
+			stringData := map[string]string { "accessToken" : "password"}
+			secret := v1.Secret{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				StringData: stringData,
+				Type:       "opaque",
+			}
+			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+			clientMock.expectedObjects[requestMock.NamespacedName] = &group
+			clientMock.expectedObjects[types.NamespacedName{
+				Namespace: "default",
+				Name:      group.Spec.GitlabCredentialsName,
+			}] = &gitlabCred
+			clientMock.expectedObjects[secretNamespacedName] = &secret
+			sut.gitlabClient = &MockGitlabClient{
+				newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
+					return &gitlab.Client{}, nil
+				},
+				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+					groups := []*gitlab.Group{ {Name: "agroup"} }
+					return groups, &gitlab.Response{
+						Response:     &http.Response{
+							Status:           "",
+							StatusCode:       0,
+							Proto:            "",
+							ProtoMajor:       0,
+							ProtoMinor:       0,
+							Header:           nil,
+							Body:             nil,
+							ContentLength:    0,
+							TransferEncoding: nil,
+							Close:            false,
+							Uncompressed:     false,
+							Trailer:          nil,
+							Request:          nil,
+							TLS:              nil,
+						},
+						TotalItems:   0,
+						TotalPages:   0,
+						ItemsPerPage: 0,
+						CurrentPage:  0,
+						NextPage:     0,
+						PreviousPage: 0,
+					}, nil
+				},
+				updateGroupFunction: func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
+					return &gitlab.Group{ Name: "agroup" }, &gitlab.Response{}, nil
+				},
+			}
+			result, err := sut.Reconcile(contextMock, requestMock)
+			It("should requeue the object", func() {
+				Expect(result).To(Equal(ctrl.Result{Requeue: true}))
+			})
+			It("should log the error", func() {
+				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+				Expect(loggerMock.loggedMessage).To(Equal(errorUnableToUpdateStatus))
+			})
+			It("should return an error", func() {
+				Expect(err).NotTo(BeNil())
+			})
+		})
+	})
+
+var _ =
+	Describe("Reconcile", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		When("processProjects fails", func() {
+			loggerMock := &MockLogger{
+				WithValuesKeysAndValues: nil,
+				WithValuesCalled:        false,
+				WithNameValue:           "",
+				WithNameCalled:          false,
+			}
+			contextMock := context.TODO()
+			clientMock := MockClient{
+				statusWriter: &MockStatusWriter{
+					updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+						return nil
+					},
+				},
+				createFunction: func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error{
+					return &MockError{message: "error"}
+				},
+			}
+			requestMock := ctrl.Request{}
+			sut := GroupReconciler{
+				Client: &clientMock,
+				Log:    loggerMock,
+				Scheme: scheme,
+			}
+			requestMock.NamespacedName = types.NamespacedName{
+				Namespace: "default",
+				Name:      "testGroup",
+			}
+			gitlabCred := gitlabv1alpha1.GitlabCredentials{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GitlabCredentialsSpec{
+					URL:      "https://example.com",
+					Username: "ausername",
+					AccessToken: v1.SecretReference{
+						Name:      "asecret",
+						Namespace: "default",
+					},
+				},
+				Status: gitlabv1alpha1.GitlabCredentialsStatus{},
+			}
+			group := gitlabv1alpha1.Group{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				Spec: gitlabv1alpha1.GroupSpec{
+					Name:                  "agroup",
+					GitlabCredentialsName: "gitlab-credentials",
+					ProjectSpecs:          []gitlabv1alpha1.ProjectSpec{ { Name: "ProjectSpec"}  },
+				},
+				Status: gitlabv1alpha1.GroupStatus{},
+			}
+			secretNamespacedName := types.NamespacedName{
+				Namespace: gitlabCred.Spec.AccessToken.Namespace,
+				Name:      gitlabCred.Spec.AccessToken.Name,
+			}
+			stringData := map[string]string { "accessToken" : "password"}
+			secret := v1.Secret{
+				TypeMeta:   metav1.TypeMeta{},
+				ObjectMeta: metav1.ObjectMeta{},
+				StringData: stringData,
+				Type:       "opaque",
+			}
+			clientMock.expectedObjects = make(map[client.ObjectKey]client.Object)
+			clientMock.expectedObjects[requestMock.NamespacedName] = &group
+			clientMock.expectedObjects[types.NamespacedName{
+				Namespace: "default",
+				Name:      group.Spec.GitlabCredentialsName,
+			}] = &gitlabCred
+			clientMock.expectedObjects[secretNamespacedName] = &secret
+			sut.gitlabClient = &MockGitlabClient{
+				newClientFunction: func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
+					return &gitlab.Client{}, nil
+				},
+				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+					groups := []*gitlab.Group{ {Name: "agroup"} }
+					return groups, &gitlab.Response{
+						Response:     &http.Response{
+							Status:           "",
+							StatusCode:       0,
+							Proto:            "",
+							ProtoMajor:       0,
+							ProtoMinor:       0,
+							Header:           nil,
+							Body:             nil,
+							ContentLength:    0,
+							TransferEncoding: nil,
+							Close:            false,
+							Uncompressed:     false,
+							Trailer:          nil,
+							Request:          nil,
+							TLS:              nil,
+						},
+						TotalItems:   0,
+						TotalPages:   0,
+						ItemsPerPage: 0,
+						CurrentPage:  0,
+						NextPage:     0,
+						PreviousPage: 0,
+					}, nil
+				},
+				updateGroupFunction: func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
+					return &gitlab.Group{ Name: "agroup" }, &gitlab.Response{}, nil
+				},
+			}
+			result, err := sut.Reconcile(contextMock, requestMock)
+			It("should requeue the object", func() {
+				Expect(result).To(Equal(ctrl.Result{Requeue: true}))
+			})
+			It("should log the error", func() {
+				Expect(loggerMock.logLevelCalled).To(Equal("Error"))
+				Expect(loggerMock.loggedMessage).To(Equal(errorUnableToProcessProjects))
+			})
+			It("should return an error", func() {
+				Expect(err).NotTo(BeNil())
+			})
+		})
+	})
+
+var _ =
+	Describe("groupExists", func() {
+		When("the gitlab client fails", func() {
+			sut := GroupReconciler{
+				gitlabClient: &MockGitlabClient{
+					listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+						return nil, &gitlab.Response{}, &MockError{
+							message: "mockedError",
+						}
+					},
+				},
+			}
+			found, response, groups, err := sut.groupExists(&gitlabv1alpha1.Group{ Spec: gitlabv1alpha1.GroupSpec{Name: "An error"}})
+			It("should return that it didn't find the group", func() {
+				Expect(found).To(Equal(false))
+			})
+			It("should return the gitlab response", func() {
+				Expect(response).ToNot(BeNil())
+			})
+			It("should return a nil group", func() {
+				Expect(groups).To(BeNil())
+			})
+			It("should return an error", func() {
+				Expect(err).ToNot(BeNil())
+			})
+		})
+		When("the group is in the list", func() {
+			group := &gitlab.Group{ Name: "A group" }
+			returnGroups := []*gitlab.Group{ group }
+			sut := GroupReconciler{
+				gitlabClient: &MockGitlabClient{
+					listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+						return returnGroups, &gitlab.Response{}, nil
+					},
+				},
+			}
+
+			found, response, returnedGroup, err := sut.groupExists(&gitlabv1alpha1.Group{ Spec: gitlabv1alpha1.GroupSpec{Name: "A group"}})
+			It("should return that it found the group", func() {
+				Expect(found).To(Equal(true))
+			})
+			It("should return the gitlab response", func() {
+				Expect(response).ToNot(BeNil())
+			})
+			It("should return list with the group", func() {
+				Expect(returnedGroup).To(Equal(group))
+			})
+			It("should not return an error", func() {
+				Expect(err).To(BeNil())
+			})
+		})
+		When("the group is not in the list", func() {
+			sut := GroupReconciler{
+				gitlabClient: &MockGitlabClient{
+					listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+						return nil, &gitlab.Response{}, nil
+					},
+				},
+			}
+
+			found, response, groups, err := sut.groupExists(&gitlabv1alpha1.Group{ Spec: gitlabv1alpha1.GroupSpec{Name: "A group"}})
+			It("should return that it did not find the group", func() {
+				Expect(found).To(Equal(false))
+			})
+			It("should return the gitlab response", func() {
+				Expect(response).ToNot(BeNil())
+			})
+			It("should return nil for the group list", func() {
+				Expect(groups).To(BeNil())
+			})
+			It("should not return an error", func() {
+				Expect(err).To(BeNil())
+			})
+		})
+	})
+var _ =
+	Describe("createGroup", func() {
+		expectedGroup := &gitlab.Group{ ID: 1, Name: "A test group"}
+		expectedResponse := &gitlab.Response{
+			Response:     &http.Response{},
+			TotalItems:   1,
+			TotalPages:   1,
+			ItemsPerPage: 10,
+			CurrentPage:  1,
+			NextPage:     0,
+			PreviousPage: 0,
+		}
+		sut := GroupReconciler{
+			gitlabClient: &MockGitlabClient{
+				createGroupFunction: func(name string, description string) (*gitlab.Group, *gitlab.Response, error) {
+					return expectedGroup, expectedResponse, nil
+				},
+			},
+		}
+		group, response, err := sut.createGroup(
+			&gitlabv1alpha1.Group{
+				ObjectMeta: ctrl.ObjectMeta{Annotations: make(map[string]string)},
+				Spec: gitlabv1alpha1.GroupSpec{Name: "a group"},
+			})
+		It("should return the gitlab group created", func() {
+			Expect(group).To(Equal(expectedGroup))
+		})
+		It("should return the gitlab response", func(){
+			Expect(response).To(Equal(expectedResponse))
+		})
+		It("should return the error created by the call, or nil", func() {
+			Expect(err).To(BeNil())
+		})
+	})
+
+var _ =
+	Describe("updateGroup", func() {
+		expectedGroup := &gitlab.Group{ID: 2, Name: "A test group"}
+		expectedResponse := &gitlab.Response{
+			Response:     &http.Response{},
+			TotalItems:   1,
+			TotalPages:   1,
+			ItemsPerPage: 10,
+			CurrentPage:  1,
+			NextPage:     0,
+			PreviousPage: 0,
+		}
+		sut := GroupReconciler{
+			gitlabClient: &MockGitlabClient{
+				updateGroupFunction: func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
+					return expectedGroup, expectedResponse, nil
+				},
+				listGroupsByNameFunction: func(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+					return []*gitlab.Group{{Name: "a group"}}, &gitlab.Response{}, nil
+				},
+			},
+		}
+		group, response, err := sut.updateGroup(
+			&gitlabv1alpha1.Group{
+				ObjectMeta: ctrl.ObjectMeta{Annotations: make(map[string]string)},
+				Spec: gitlabv1alpha1.GroupSpec{Name: "a group"},
+				Status: gitlabv1alpha1.GroupStatus{
+					GitlabID:        nil,
+					CreatedTime:     metav1.Time{},
+					LastUpdatedTime: metav1.Time{},
+					State:           "",
+				},
+			})
+		It("should return the gitlab group created", func() {
+			Expect(group).To(Equal(expectedGroup))
+		})
+		It("should return the gitlab response", func(){
+			Expect(response).To(Equal(expectedResponse))
+		})
+		It("should return the error created by the call, or nil", func() {
+			Expect(err).To(BeNil())
+		})
+	})
+
+var _ =
+	Describe("SetupWithManager", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		loggerMock := MockLogger{
+			WithValuesKeysAndValues: nil,
+			WithValuesCalled:        false,
+			WithNameValue:           "",
+			WithNameCalled:          false,
+		}
+		clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+			return nil
+		}}}
+		sut := GroupReconciler{
+			Client: &clientMock,
+			Log:    &loggerMock,
+			Scheme: scheme,
+		}
+		err := sut.SetupWithManager(&MockManager{
+			Log: &loggerMock,
+			builder: builder,
+		})
+		It("should setup the default gitlab client", func() {
+			Expect(sut.gitlabClient).To(BeAssignableToTypeOf(&ClientImpl{}))
+		})
+		It("should return no error", func() {
+			Expect(err).To(BeNil())
+		})
+	})
+
+var _ = Describe("updateStatus", func() {
+	When("group id is not 0", func() {
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		loggerMock := MockLogger{
+			WithValuesKeysAndValues: nil,
+			WithValuesCalled:        false,
+			WithNameValue:           "",
+			WithNameCalled:          false,
+		}
+		clientMock := MockClient{ statusWriter: MockStatusWriter{updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+			return nil
+		}}}
+		sut := GroupReconciler{
+			Client: &clientMock,
+			Log:    &loggerMock,
+			Scheme: scheme,
+		}
+		group := gitlabv1alpha1.Group{Status: gitlabv1alpha1.GroupStatus{
+			GitlabID:        nil,
+			CreatedTime:     metav1.Time{},
+			LastUpdatedTime: metav1.Time{},
+			State:           "",
+		}}
+		sut.updateStatus(&MockContext{}, 1, &group)
+
+		It("should update the gitlab id", func() {
+			Expect(*group.Status.GitlabID).To(Equal(int64(1)))
+		})
+		It("should update the last updated time", func() {
+			Expect(group.Status.LastUpdatedTime.Time).To(Not(BeNil()))
+		})
+	})
+})
+
+var _ =
+	Describe("updateProject", func() {
+		spec := gitlabv1alpha1.ProjectSpec{
+			Name:           "a project",
+			Path:           "https://example.com.path",
+			ImpactLevel:    "2",
+			StorageTypes:   nil,
+			VirtualService: "default",
+			ServicePort:    8081,
+			Language:       "golang",
+		}
+		project := gitlabv1alpha1.Project{Spec: gitlabv1alpha1.ProjectSpec{}}
+		builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Group{}, &gitlabv1alpha1.GroupList{})
+		scheme, _ := builder.Build()
+		loggerMock := MockLogger{
+			WithValuesKeysAndValues: nil,
+			WithValuesCalled:        false,
+			WithNameValue:           "",
+			WithNameCalled:          false,
+		}
+		mockError := &MockError{"true"}
+		clientMock := MockClient{
+			statusWriter: MockStatusWriter{
+				updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+					return nil
+				},
+			},
+			updateFunction: func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+				return mockError
+			},
+		}
+		sut := GroupReconciler{
+			Client: &clientMock,
+			Log:    &loggerMock,
+			Scheme: scheme,
+		}
+
+		returnedProject, err := sut.updateProject(context.TODO(), 1, spec, &project)
+		It("should update the project from the project specification", func() {
+			Expect(project.Spec.GroupID).To(Equal(int64(1)))
+			Expect(project.Spec.Name).To(Equal(spec.Name))
+			Expect(project.Spec.ServicePort).To(Equal(spec.ServicePort))
+			Expect(project.Spec.Language).To(Equal(spec.Language))
+			Expect(project.Spec.Path).To(Equal(spec.Path))
+			Expect(project.Spec.VirtualService).To(Equal(spec.VirtualService))
+			Expect(project.Spec.StorageTypes).To(Equal(spec.StorageTypes))
+			Expect(project.Spec.ImpactLevel).To(Equal(spec.ImpactLevel))
+		})
+		It("should call the kubernetes client update function", func() {
+			Expect(clientMock.updateFunctionCalled).To(BeTrue())
+		})
+		It("should return the result of the update function", func() {
+			Expect(err).To(Equal(mockError))
+		})
+		It("should return the updated project", func() {
+			Expect(project).To(Equal(*returnedProject))
+		})
+	})
\ No newline at end of file
diff --git a/controllers/gitlab/mocks_test.go b/controllers/gitlab/mocks_test.go
index 1716f5dd15337006e9907a76d7d0dcd57707e41e..2ae549627c7dfa1730c5bd683fbd8679d5d8d2f0 100755
--- a/controllers/gitlab/mocks_test.go
+++ b/controllers/gitlab/mocks_test.go
@@ -1,423 +1,436 @@
-package gitlab
-
-import (
-	"context"
-	"github.com/go-logr/logr"
-	"github.com/jinzhu/copier"
-	"github.com/xanzy/go-gitlab"
-	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/api/meta"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-	"k8s.io/client-go/rest"
-	"k8s.io/client-go/tools/record"
-	"net/http"
-	"sigs.k8s.io/controller-runtime/pkg/cache"
-	"sigs.k8s.io/controller-runtime/pkg/client"
-	"sigs.k8s.io/controller-runtime/pkg/healthz"
-	"sigs.k8s.io/controller-runtime/pkg/log/zap"
-	"sigs.k8s.io/controller-runtime/pkg/manager"
-	"sigs.k8s.io/controller-runtime/pkg/scheme"
-	"sigs.k8s.io/controller-runtime/pkg/webhook"
-	"time"
-	"valkyrie.dso.mil/valkyrie-api/controllers"
-)
-
-type MockClient struct {
-	GetFunction          func(ctx context.Context, key client.ObjectKey, obj client.Object) error
-	GetCalled            bool
-	expectedObjects      map[client.ObjectKey]client.Object
-	NotFoundError        error
-	statusWriter         client.StatusWriter
-	createFunction       func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error
-	updateFunction       func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error
-	updateFunctionCalled bool
-}
-
-func (m *MockClient) Get(ctx context.Context, key client.ObjectKey, obj client.Object) error {
-	m.GetCalled = true
-	if m.GetFunction != nil {
-		return m.GetFunction(ctx, key, obj)
-	}
-
-	if m.expectedObjects == nil {
-		return nil
-	}
-
-	if m.expectedObjects[key] == nil {
-		return &errors.StatusError{
-			ErrStatus: metav1.Status{
-				TypeMeta: metav1.TypeMeta{},
-				ListMeta: metav1.ListMeta{},
-				Status:   string(metav1.StatusReasonNotFound),
-				Message:  "NotFound",
-				Reason:   metav1.StatusReasonNotFound,
-				Details:  nil,
-				Code:     0,
-			},
-		}
-	}
-
-	foundObject := m.expectedObjects[key]
-
-	copier.Copy(obj, foundObject)
-
-	return nil
-}
-
-func (m *MockClient) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
-	panic("implement me")
-}
-
-func (m *MockClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
-	if m.createFunction == nil {
-		return nil
-	}
-	return m.createFunction(ctx, obj, opts...)
-}
-
-func (m *MockClient) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error {
-	panic("implement me")
-}
-
-func (m *MockClient) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-	m.updateFunctionCalled = true
-	if m.updateFunction == nil {
-		return nil
-	}
-	return m.updateFunction(ctx, obj, opts...)
-}
-
-func (m *MockClient) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
-	panic("implement me")
-}
-
-func (m *MockClient) DeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error {
-	panic("implement me")
-}
-
-type MockStatusWriter struct {
-	updateFunction func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error
-}
-
-func (m MockStatusWriter) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
-	return m.updateFunction(ctx, obj, opts...)
-}
-
-func (m MockStatusWriter) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
-	panic("implement me")
-}
-
-func (m *MockClient) Status() client.StatusWriter {
-	return m.statusWriter
-}
-
-func (m *MockClient) Scheme() *runtime.Scheme {
-	panic("implement me")
-}
-
-func (m *MockClient) RESTMapper() meta.RESTMapper {
-	panic("implement me")
-}
-
-type MockContext struct {
-}
-
-func (m *MockContext) Deadline() (deadline time.Time, ok bool) {
-	panic("implement me")
-}
-
-func (m *MockContext) Done() <-chan struct{} {
-	panic("implement me")
-}
-
-func (m *MockContext) Err() error {
-	panic("implement me")
-}
-
-func (m *MockContext) Value(key interface{}) interface{} {
-	panic("implement me")
-}
-
-type MockLogger struct {
-	WithValuesKeysAndValues []interface{}
-	WithValuesCalled        bool
-	WithNameValue           string
-	WithNameCalled          bool
-	loggedMessage           string
-	keysAndValues           []interface{}
-	logFunction             func(msg string, keysAndValues ...interface{})
-	logLevelCalled          string
-	level                   int
-}
-
-func (m *MockLogger) Enabled() bool {
-	return true
-}
-
-func (m *MockLogger) Info(msg string, keysAndValues ...interface{}) {
-	m.loggedMessage = msg
-	m.keysAndValues = keysAndValues
-	m.logLevelCalled = "Info"
-	if m.logFunction != nil {
-		m.logFunction(msg, keysAndValues)
-		return
-	}
-}
-
-func (m *MockLogger) Error(err error, msg string, keysAndValues ...interface{}) {
-	m.loggedMessage = msg
-	m.keysAndValues = keysAndValues
-	m.logLevelCalled = "Error"
-	if m.logFunction != nil {
-		m.logFunction(msg, keysAndValues)
-		return
-	}
-}
-
-func (m *MockLogger) V(level int) logr.Logger {
-	m.level = level
-	return m
-}
-
-func (m *MockLogger) WithValues(keysAndValues ...interface{}) logr.Logger {
-	m.WithValuesCalled = true
-	for i := 0; i < len(keysAndValues); i++ {
-		m.WithValuesKeysAndValues = append(m.WithValuesKeysAndValues, keysAndValues[i])
-	}
-	m.WithValuesKeysAndValues = append(m.WithValuesKeysAndValues, keysAndValues)
-
-	return m
-}
-
-func (m *MockLogger) WithName(name string) logr.Logger {
-	m.WithNameCalled = true
-	m.WithNameValue = name
-	return m
-}
-
-type MockController struct {
-	setupWithManagerWasCalled bool
-}
-
-func (m *MockController) SetupWithManager(manager manager.Manager) error {
-	m.setupWithManagerWasCalled = true
-	return nil
-}
-
-type MockManager struct {
-	Log                      logr.Logger
-	addHealthzCheckFunction  func(name string, check healthz.Checker) error
-	addHealthzCheckWasCalled bool
-	addReadyzCheckFunction   func(name string, check healthz.Checker) error
-	addReadyzCheckWasCalled  bool
-	startFunction            func(ctx context.Context) error
-	startWasCalled           bool
-	builder                  *scheme.Builder
-	Fields                   []interface{}
-	runnable                 manager.Runnable
-}
-
-func (m *MockManager) Add(runnable manager.Runnable) error {
-	m.runnable = runnable
-
-	return nil
-}
-
-func (m *MockManager) Elected() <-chan struct{} {
-	panic("implement me")
-}
-
-func (m *MockManager) SetFields(i interface{}) error {
-	if m.Fields == nil {
-		m.Fields = make([]interface{}, 0)
-	}
-	m.Fields = append(m.Fields, i)
-
-	return nil
-}
-
-func (m *MockManager) AddMetricsExtraHandler(path string, handler http.Handler) error {
-	panic("implement me")
-}
-
-func (m *MockManager) AddHealthzCheck(name string, check healthz.Checker) error {
-	m.addHealthzCheckWasCalled = true
-	if m.addHealthzCheckFunction == nil {
-		return nil
-	}
-	return m.addHealthzCheckFunction(name, check)
-}
-
-func (m *MockManager) AddReadyzCheck(name string, check healthz.Checker) error {
-	m.addReadyzCheckWasCalled = true
-	if m.addReadyzCheckFunction == nil {
-		return nil
-	}
-
-	return m.addReadyzCheckFunction(name, check)
-}
-
-func (m *MockManager) Start(ctx context.Context) error {
-	m.startWasCalled = true
-	if m.startFunction == nil {
-		return nil
-	}
-	return m.startFunction(ctx)
-}
-
-func (m *MockManager) GetConfig() *rest.Config {
-	return &rest.Config{}
-}
-
-func (m *MockManager) GetScheme() *runtime.Scheme {
-	scheme, _ := m.builder.Build()
-	return scheme
-}
-
-func (m *MockManager) GetClient() client.Client {
-	return nil
-}
-
-func (m *MockManager) GetFieldIndexer() client.FieldIndexer {
-	panic("implement me")
-}
-
-func (m *MockManager) GetCache() cache.Cache {
-	panic("implement me")
-}
-
-func (m *MockManager) GetEventRecorderFor(name string) record.EventRecorder {
-	panic("implement me")
-}
-
-func (m *MockManager) GetRESTMapper() meta.RESTMapper {
-	panic("implement me")
-}
-
-func (m *MockManager) GetAPIReader() client.Reader {
-	panic("implement me")
-}
-
-func (m *MockManager) GetWebhookServer() *webhook.Server {
-	panic("implement me")
-}
-
-func (m *MockManager) GetLogger() logr.Logger {
-	return m.Log
-}
-
-type MockRunFunctionParameters struct {
-	options              zap.Options
-	metricsAddress       string
-	healthProbeAddress   string
-	enableLeaderElection bool
-}
-
-type MockDriver struct {
-	parseCommandLineCalled           bool
-	parseCommandLineFunction         func() (string, bool, string, zap.Options, error)
-	runCalled                        bool
-	runFunction                      func(opts zap.Options, metricsAddress string, healthProbeAddress string, enableLeaderElection bool) (int, error)
-	runFunctionParameters            MockRunFunctionParameters
-	newManagerCalled                 bool
-	newManagerFunction               func(metricsAddress string, healthProbeAddress string, enableLeaderElection bool) (manager.Manager, error)
-	instantiateControllersCalled     bool
-	instantiateControllersFunction   func(mgr manager.Manager) []controllers.ManagedController
-	setupControllerWithManagerCalled bool
-	setupControllersFunction         func(controller controllers.ManagedController, manager manager.Manager) error
-}
-
-func (m *MockDriver) parseCommandLine() (string, bool, string, zap.Options, error) {
-	m.parseCommandLineCalled = true
-	if m.parseCommandLineFunction == nil {
-		return "", true, "", zap.Options{}, nil
-	}
-
-	return m.parseCommandLineFunction()
-}
-
-func (m *MockDriver) run(opts zap.Options, metricsAddress string, healthProbeAddress string, enableLeaderElection bool) (int, error) {
-	m.runCalled = true
-	m.runFunctionParameters = MockRunFunctionParameters{
-		options:              opts,
-		metricsAddress:       metricsAddress,
-		healthProbeAddress:   healthProbeAddress,
-		enableLeaderElection: enableLeaderElection,
-	}
-	if m.runFunction == nil {
-		return 0, nil
-	}
-
-	return m.runFunction(opts, metricsAddress, healthProbeAddress, enableLeaderElection)
-}
-
-func (m *MockDriver) newManager(metricsAddress string, healthProbeAddress string, enableLeaderElection bool) (manager.Manager, error) {
-	m.newManagerCalled = true
-	if m.newManagerFunction == nil {
-		return &MockManager{}, nil
-	}
-
-	return m.newManagerFunction(metricsAddress, healthProbeAddress, enableLeaderElection)
-}
-
-func (m *MockDriver) instantiateControllers(mgr manager.Manager) []controllers.ManagedController {
-	m.instantiateControllersCalled = true
-
-	if m.instantiateControllersFunction == nil {
-		return []controllers.ManagedController{
-			&MockController{},
-		}
-	}
-
-	return m.instantiateControllersFunction(mgr)
-}
-
-func (m *MockDriver) setupControllerWithManager(controller controllers.ManagedController, manager manager.Manager) error {
-	m.setupControllerWithManagerCalled = true
-
-	if m.setupControllersFunction == nil {
-		return nil
-	}
-
-	return m.setupControllersFunction(controller, manager)
-}
-
-type MockError struct {
-	message string
-}
-
-func (m *MockError) Error() string {
-	if m.message == "" {
-		m.message = "mock Error"
-	}
-	return m.message
-}
-
-type MockGitlabClient struct {
-	newClientFunction        func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error)
-	listGroupsFunction       func(opt *gitlab.ListGroupsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Group, *gitlab.Response, error)
-	listGroupsByNameFunction func(name string) ([]*gitlab.Group, *gitlab.Response, error)
-	createGroupFunction      func(name string, description string) (*gitlab.Group, *gitlab.Response, error)
-	updateGroupFunction      func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error)
-}
-
-func (m *MockGitlabClient) CreateGroup(name string, description string) (*gitlab.Group, *gitlab.Response, error) {
-	return m.createGroupFunction(name, description)
-}
-
-func (m *MockGitlabClient) UpdateGroup(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
-	return m.updateGroupFunction(id, name, description)
-}
-
-func (m *MockGitlabClient) ListGroupsByName(name string) ([]*gitlab.Group, *gitlab.Response, error) {
-	return m.listGroupsByNameFunction(name)
-}
-
-func (m *MockGitlabClient) NewClient(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
-	return m.newClientFunction(token, options...)
-}
-
-func (m *MockGitlabClient) ListGroups(opt *gitlab.ListGroupsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Group, *gitlab.Response, error) {
-	return m.listGroupsFunction(opt, options...)
-}
+package gitlab
+
+import (
+	"context"
+	"github.com/go-logr/logr"
+	"github.com/jinzhu/copier"
+	"github.com/xanzy/go-gitlab"
+	"k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/record"
+	"net/http"
+	"sigs.k8s.io/controller-runtime/pkg/cache"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	"sigs.k8s.io/controller-runtime/pkg/healthz"
+	"sigs.k8s.io/controller-runtime/pkg/log/zap"
+	"sigs.k8s.io/controller-runtime/pkg/manager"
+	"sigs.k8s.io/controller-runtime/pkg/scheme"
+	"sigs.k8s.io/controller-runtime/pkg/webhook"
+	"time"
+	"valkyrie.dso.mil/valkyrie-api/controllers"
+)
+
+type MockClient struct {
+	GetFunction          func(ctx context.Context, key client.ObjectKey, obj client.Object) error
+	GetCalled            bool
+	expectedObjects      map[client.ObjectKey]client.Object
+	NotFoundError        error
+	statusWriter         client.StatusWriter
+	createFunction       func(ctx context.Context, obj client.Object, opts ...client.CreateOption) error
+	updateFunction       func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error
+	updateFunctionCalled bool
+	schemeFunction       func() *runtime.Scheme
+}
+
+func (m *MockClient) Get(ctx context.Context, key client.ObjectKey, obj client.Object) error {
+	m.GetCalled = true
+	if m.GetFunction != nil {
+		return m.GetFunction(ctx, key, obj)
+	}
+
+	if m.expectedObjects == nil {
+		return nil
+	}
+
+	if m.expectedObjects[key] == nil {
+		return &errors.StatusError{
+			ErrStatus: metav1.Status{
+				TypeMeta: metav1.TypeMeta{},
+				ListMeta: metav1.ListMeta{},
+				Status:   string(metav1.StatusReasonNotFound),
+				Message:  "NotFound",
+				Reason:   metav1.StatusReasonNotFound,
+				Details:  nil,
+				Code:     0,
+			},
+		}
+	}
+
+	foundObject := m.expectedObjects[key]
+
+	copier.Copy(obj, foundObject)
+
+	return nil
+}
+
+func (m *MockClient) List(ctx context.Context, list client.ObjectList, opts ...client.ListOption) error {
+	panic("implement me")
+}
+
+func (m *MockClient) Create(ctx context.Context, obj client.Object, opts ...client.CreateOption) error {
+	if m.createFunction == nil {
+		return nil
+	}
+	return m.createFunction(ctx, obj, opts...)
+}
+
+func (m *MockClient) Delete(ctx context.Context, obj client.Object, opts ...client.DeleteOption) error {
+	panic("implement me")
+}
+
+func (m *MockClient) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+	m.updateFunctionCalled = true
+	if m.updateFunction == nil {
+		return nil
+	}
+	return m.updateFunction(ctx, obj, opts...)
+}
+
+func (m *MockClient) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
+	panic("implement me")
+}
+
+func (m *MockClient) DeleteAllOf(ctx context.Context, obj client.Object, opts ...client.DeleteAllOfOption) error {
+	panic("implement me")
+}
+
+type MockStatusWriter struct {
+	updateFunction func(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error
+	patchFunction func(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error
+}
+
+func (m MockStatusWriter) Update(ctx context.Context, obj client.Object, opts ...client.UpdateOption) error {
+	if m.updateFunction == nil {
+		return nil
+	}
+	return m.updateFunction(ctx, obj, opts...)
+}
+
+func (m MockStatusWriter) Patch(ctx context.Context, obj client.Object, patch client.Patch, opts ...client.PatchOption) error {
+	if m.patchFunction == nil {
+		return nil
+	}
+
+	return m.patchFunction(ctx, obj, patch, opts...)
+}
+
+func (m *MockClient) Status() client.StatusWriter {
+	return m.statusWriter
+}
+
+func (m *MockClient) Scheme() *runtime.Scheme {
+	if m.schemeFunction == nil {
+		return &runtime.Scheme{}
+	}
+	return m.schemeFunction()
+}
+
+func (m *MockClient) RESTMapper() meta.RESTMapper {
+	panic("implement me")
+}
+
+type MockContext struct {
+}
+
+func (m *MockContext) Deadline() (deadline time.Time, ok bool) {
+	panic("implement me")
+}
+
+func (m *MockContext) Done() <-chan struct{} {
+	panic("implement me")
+}
+
+func (m *MockContext) Err() error {
+	panic("implement me")
+}
+
+func (m *MockContext) Value(key interface{}) interface{} {
+	panic("implement me")
+}
+
+type MockLogger struct {
+	WithValuesKeysAndValues []interface{}
+	WithValuesCalled        bool
+	WithNameValue           string
+	WithNameCalled          bool
+	loggedMessage           string
+	keysAndValues           []interface{}
+	logFunction             func(msg string, keysAndValues ...interface{})
+	logLevelCalled          string
+	level                   int
+}
+
+func (m *MockLogger) Enabled() bool {
+	return true
+}
+
+func (m *MockLogger) Info(msg string, keysAndValues ...interface{}) {
+	m.loggedMessage = msg
+	m.keysAndValues = keysAndValues
+	m.logLevelCalled = "Info"
+	if m.logFunction != nil {
+		m.logFunction(msg, keysAndValues)
+		return
+	}
+}
+
+func (m *MockLogger) Error(err error, msg string, keysAndValues ...interface{}) {
+	m.loggedMessage = msg
+	m.keysAndValues = keysAndValues
+	m.logLevelCalled = "Error"
+	if m.logFunction != nil {
+		m.logFunction(msg, keysAndValues)
+		return
+	}
+}
+
+func (m *MockLogger) V(level int) logr.Logger {
+	m.level = level
+	return m
+}
+
+func (m *MockLogger) WithValues(keysAndValues ...interface{}) logr.Logger {
+	m.WithValuesCalled = true
+	for i := 0; i < len(keysAndValues); i++ {
+		m.WithValuesKeysAndValues = append(m.WithValuesKeysAndValues, keysAndValues[i])
+	}
+	m.WithValuesKeysAndValues = append(m.WithValuesKeysAndValues, keysAndValues)
+
+	return m
+}
+
+func (m *MockLogger) WithName(name string) logr.Logger {
+	m.WithNameCalled = true
+	m.WithNameValue = name
+	return m
+}
+
+type MockController struct {
+	setupWithManagerWasCalled bool
+}
+
+func (m *MockController) SetupWithManager(manager manager.Manager) error {
+	m.setupWithManagerWasCalled = true
+	return nil
+}
+
+type MockManager struct {
+	Log                      logr.Logger
+	addHealthzCheckFunction  func(name string, check healthz.Checker) error
+	addHealthzCheckWasCalled bool
+	addReadyzCheckFunction   func(name string, check healthz.Checker) error
+	addReadyzCheckWasCalled  bool
+	startFunction            func(ctx context.Context) error
+	startWasCalled           bool
+	builder                  *scheme.Builder
+	Fields                   []interface{}
+	runnable                 manager.Runnable
+}
+
+func (m *MockManager) Add(runnable manager.Runnable) error {
+	m.runnable = runnable
+
+	return nil
+}
+
+func (m *MockManager) Elected() <-chan struct{} {
+	panic("implement me")
+}
+
+func (m *MockManager) SetFields(i interface{}) error {
+	if m.Fields == nil {
+		m.Fields = make([]interface{}, 0)
+	}
+	m.Fields = append(m.Fields, i)
+
+	return nil
+}
+
+func (m *MockManager) AddMetricsExtraHandler(path string, handler http.Handler) error {
+	panic("implement me")
+}
+
+func (m *MockManager) AddHealthzCheck(name string, check healthz.Checker) error {
+	m.addHealthzCheckWasCalled = true
+	if m.addHealthzCheckFunction == nil {
+		return nil
+	}
+	return m.addHealthzCheckFunction(name, check)
+}
+
+func (m *MockManager) AddReadyzCheck(name string, check healthz.Checker) error {
+	m.addReadyzCheckWasCalled = true
+	if m.addReadyzCheckFunction == nil {
+		return nil
+	}
+
+	return m.addReadyzCheckFunction(name, check)
+}
+
+func (m *MockManager) Start(ctx context.Context) error {
+	m.startWasCalled = true
+	if m.startFunction == nil {
+		return nil
+	}
+	return m.startFunction(ctx)
+}
+
+func (m *MockManager) GetConfig() *rest.Config {
+	return &rest.Config{}
+}
+
+func (m *MockManager) GetScheme() *runtime.Scheme {
+	scheme, _ := m.builder.Build()
+	return scheme
+}
+
+func (m *MockManager) GetClient() client.Client {
+	return nil
+}
+
+func (m *MockManager) GetFieldIndexer() client.FieldIndexer {
+	panic("implement me")
+}
+
+func (m *MockManager) GetCache() cache.Cache {
+	panic("implement me")
+}
+
+func (m *MockManager) GetEventRecorderFor(name string) record.EventRecorder {
+	panic("implement me")
+}
+
+func (m *MockManager) GetRESTMapper() meta.RESTMapper {
+	panic("implement me")
+}
+
+func (m *MockManager) GetAPIReader() client.Reader {
+	panic("implement me")
+}
+
+func (m *MockManager) GetWebhookServer() *webhook.Server {
+	panic("implement me")
+}
+
+func (m *MockManager) GetLogger() logr.Logger {
+	return m.Log
+}
+
+type MockRunFunctionParameters struct {
+	options              zap.Options
+	metricsAddress       string
+	healthProbeAddress   string
+	enableLeaderElection bool
+}
+
+type MockDriver struct {
+	parseCommandLineCalled           bool
+	parseCommandLineFunction         func() (string, bool, string, zap.Options, error)
+	runCalled                        bool
+	runFunction                      func(opts zap.Options, metricsAddress string, healthProbeAddress string, enableLeaderElection bool) (int, error)
+	runFunctionParameters            MockRunFunctionParameters
+	newManagerCalled                 bool
+	newManagerFunction               func(metricsAddress string, healthProbeAddress string, enableLeaderElection bool) (manager.Manager, error)
+	instantiateControllersCalled     bool
+	instantiateControllersFunction   func(mgr manager.Manager) []controllers.ManagedController
+	setupControllerWithManagerCalled bool
+	setupControllersFunction         func(controller controllers.ManagedController, manager manager.Manager) error
+}
+
+func (m *MockDriver) parseCommandLine() (string, bool, string, zap.Options, error) {
+	m.parseCommandLineCalled = true
+	if m.parseCommandLineFunction == nil {
+		return "", true, "", zap.Options{}, nil
+	}
+
+	return m.parseCommandLineFunction()
+}
+
+func (m *MockDriver) run(opts zap.Options, metricsAddress string, healthProbeAddress string, enableLeaderElection bool) (int, error) {
+	m.runCalled = true
+	m.runFunctionParameters = MockRunFunctionParameters{
+		options:              opts,
+		metricsAddress:       metricsAddress,
+		healthProbeAddress:   healthProbeAddress,
+		enableLeaderElection: enableLeaderElection,
+	}
+	if m.runFunction == nil {
+		return 0, nil
+	}
+
+	return m.runFunction(opts, metricsAddress, healthProbeAddress, enableLeaderElection)
+}
+
+func (m *MockDriver) newManager(metricsAddress string, healthProbeAddress string, enableLeaderElection bool) (manager.Manager, error) {
+	m.newManagerCalled = true
+	if m.newManagerFunction == nil {
+		return &MockManager{}, nil
+	}
+
+	return m.newManagerFunction(metricsAddress, healthProbeAddress, enableLeaderElection)
+}
+
+func (m *MockDriver) instantiateControllers(mgr manager.Manager) []controllers.ManagedController {
+	m.instantiateControllersCalled = true
+
+	if m.instantiateControllersFunction == nil {
+		return []controllers.ManagedController{
+			&MockController{},
+		}
+	}
+
+	return m.instantiateControllersFunction(mgr)
+}
+
+func (m *MockDriver) setupControllerWithManager(controller controllers.ManagedController, manager manager.Manager) error {
+	m.setupControllerWithManagerCalled = true
+
+	if m.setupControllersFunction == nil {
+		return nil
+	}
+
+	return m.setupControllersFunction(controller, manager)
+}
+
+type MockError struct {
+	message string
+}
+
+func (m *MockError) Error() string {
+	if m.message == "" {
+		m.message = "mock Error"
+	}
+	return m.message
+}
+
+type MockGitlabClient struct {
+	newClientFunction func(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error)
+	listGroupsFunction func(opt *gitlab.ListGroupsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Group, *gitlab.Response, error)
+	listGroupsByNameFunction func(name string) ([]*gitlab.Group, *gitlab.Response, error)
+	createGroupFunction func(name string, description string) (*gitlab.Group, *gitlab.Response, error)
+	updateGroupFunction func(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error)
+
+}
+
+func (m *MockGitlabClient) CreateGroup(name string, description string) (*gitlab.Group, *gitlab.Response, error) {
+	return m.createGroupFunction(name, description)
+}
+
+func (m *MockGitlabClient) UpdateGroup(id string, name string, description string) (*gitlab.Group, *gitlab.Response, error) {
+	return m.updateGroupFunction(id, name, description)
+}
+
+func (m *MockGitlabClient) ListGroupsByName(name string) ([]*gitlab.Group, *gitlab.Response, error) {
+	return m.listGroupsByNameFunction(name)
+}
+
+func (m *MockGitlabClient) NewClient(token string, options ...gitlab.ClientOptionFunc) (*gitlab.Client, error) {
+	return m.newClientFunction(token, options...)
+}
+
+func (m *MockGitlabClient) ListGroups(opt *gitlab.ListGroupsOptions, options ...gitlab.RequestOptionFunc) ([]*gitlab.Group, *gitlab.Response, error) {
+	return m.listGroupsFunction(opt, options...)
+}
diff --git a/controllers/gitlab/project_controller.go b/controllers/gitlab/project_controller.go
index ac64eb1b0e93bfb9d06d0c261efadc6cc9156759..d115ef8a0df1918fc52a0003da5ee2aeb3d7d74d 100644
--- a/controllers/gitlab/project_controller.go
+++ b/controllers/gitlab/project_controller.go
@@ -18,7 +18,6 @@ package gitlab
 
 import (
 	"context"
-
 	"github.com/go-logr/logr"
 	"k8s.io/apimachinery/pkg/runtime"
 	ctrl "sigs.k8s.io/controller-runtime"
@@ -32,6 +31,7 @@ type ProjectReconciler struct {
 	client.Client
 	Log    logr.Logger
 	Scheme *runtime.Scheme
+	gitlabClient Client
 }
 
 //+kubebuilder:rbac:groups=gitlab.valkyrie.dso.mil,resources=projects,verbs=get;list;watch;create;update;patch;delete
@@ -47,17 +47,41 @@ type ProjectReconciler struct {
 //
 // For more details, check Reconcile and its Result here:
 // - https://pkg.go.dev/sigs.k8s.io/controller-runtime@v0.7.2/pkg/reconcile
+
+// errors
+const (
+	errorWhileLookingUpProject string = "error while looking up project"
+)
+
+// Reconcile is the main reconcilation loop that will create/edit/delete Gitlab Projects.
 func (r *ProjectReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
 	_ = r.Log.WithValues("project", req.NamespacedName)
 
-	// your logic here
+	if _, err := r.getProject(ctx, req); err != nil {
+		r.Log.Error(err, errorWhileLookingUpProject, "request", req)
+		return ctrl.Result{Requeue: client.IgnoreNotFound(err) != nil}, client.IgnoreNotFound(err)
+	}
 
 	return ctrl.Result{}, nil
 }
 
 // SetupWithManager sets up the controller with the Manager.
 func (r *ProjectReconciler) SetupWithManager(mgr ctrl.Manager) error {
+	r.gitlabClient = ClientImpl{}
+
 	return ctrl.NewControllerManagedBy(mgr).
 		For(&gitlabv1alpha1.Project{}).
+		Owns(&gitlabv1alpha1.Pipeline{}).
 		Complete(r)
 }
+
+func (r *ProjectReconciler) getProject(ctx context.Context, request ctrl.Request) (*gitlabv1alpha1.Project, error) {
+	var project gitlabv1alpha1.Project
+	if err := r.Client.Get(ctx, request.NamespacedName, &project); err != nil {
+		if client.IgnoreNotFound(err) == nil {
+			return nil, err
+		}
+		return &project, err
+	}
+	return &project, nil
+}
diff --git a/controllers/gitlab/project_controller_test.go b/controllers/gitlab/project_controller_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ec96fe25b3375fc488c150432e3bd6ebcc8e8837
--- /dev/null
+++ b/controllers/gitlab/project_controller_test.go
@@ -0,0 +1,196 @@
+package gitlab
+
+import (
+	"context"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	ctrl "sigs.k8s.io/controller-runtime"
+	"sigs.k8s.io/controller-runtime/pkg/client"
+	gitlabv1alpha1 "valkyrie.dso.mil/valkyrie-api/apis/gitlab/v1alpha1"
+)
+
+func getControllerWithMocksInGreenTestState() (ProjectReconciler, *MockManager, *MockLogger) {
+	builder := gitlabv1alpha1.SchemeBuilder.Register(&gitlabv1alpha1.Project{}, &gitlabv1alpha1.ProjectList{})
+	scheme, _ := builder.Build()
+
+	loggerMock := MockLogger{
+		WithValuesKeysAndValues: nil,
+		WithValuesCalled:        false,
+		WithNameValue:           "",
+		WithNameCalled:          false,
+	}
+	clientMock := MockClient{
+		statusWriter:         MockStatusWriter{},
+		expectedObjects: make(map[client.ObjectKey]client.Object),
+	}
+	clientMock.expectedObjects[getRequestWithDefaultNamespacedTestProject().NamespacedName] = &gitlabv1alpha1.Project{
+		TypeMeta:   metav1.TypeMeta{},
+		ObjectMeta: metav1.ObjectMeta{
+			Name:                       "TestProject",
+			Namespace:                  "default",
+		},
+		Spec:       gitlabv1alpha1.ProjectSpec{
+			Name:           "TestProject",
+			Path:           "https://example.com/TestProject",
+			ImpactLevel:    "2",
+			StorageTypes:   nil,
+			VirtualService: "default",
+			ServicePort:    8081,
+			Language:       "golang",
+		},
+		Status:     gitlabv1alpha1.ProjectStatus{},
+	}
+	mockManager := &MockManager{
+		Log: &loggerMock,
+		builder: builder,
+	}
+
+	sut := ProjectReconciler{
+		Client: &clientMock,
+		Log:    &loggerMock,
+		Scheme: scheme,
+	}
+	return sut, mockManager, &loggerMock
+}
+
+func getRequestWithDefaultNamespacedTestProject() ctrl.Request {
+	return ctrl.Request{
+		NamespacedName: types.NamespacedName{
+			Namespace: "default",
+			Name: "TestProject",
+		},
+	}
+}
+
+var _ = Describe("SetupWithManager", func() {
+	sut, mgr, _ := getControllerWithMocksInGreenTestState()
+
+	err := sut.SetupWithManager(mgr)
+
+	It("should setup the default gitlab client", func() {
+		Expect(sut.gitlabClient).To(BeAssignableToTypeOf(ClientImpl{}))
+	})
+	It("should return no error", func() {
+		Expect(err).To(BeNil())
+	})
+})
+
+var _ = Describe("reconcile", func() {
+	Context("green state", func() {
+		sut, _, _ := getControllerWithMocksInGreenTestState()
+		request := getRequestWithDefaultNamespacedTestProject()
+		result, err := sut.Reconcile(context.TODO(), request)
+		It("should return an empty result", func() {
+			Expect(result).To(Equal(ctrl.Result{}))
+		})
+		It("should return no error", func() {
+			Expect(err).To(BeNil())
+		})
+	})
+	Context("project isn't found", func() {
+		sut, _, log := getControllerWithMocksInGreenTestState()
+		request := getRequestWithDefaultNamespacedTestProject()
+		request.NamespacedName.Name = "not going to find it"
+		result, err := sut.Reconcile(context.TODO(), request)
+		It("should return no error", func() {
+			Expect(err).To(BeNil())
+		})
+		It("should not requeue the object", func() {
+			Expect(result).To(Equal(ctrl.Result{Requeue: false}))
+		})
+		It("should log that there was an error looking for the project", func() {
+			Expect(log.loggedMessage).To(Equal(errorWhileLookingUpProject))
+		})
+	})
+	Context("getProject returns an error", func() {
+		sut, _, log := getControllerWithMocksInGreenTestState()
+		failingClient := MockClient{
+			GetFunction: func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
+				return &MockError{
+					message: "Error while doing a get.",
+				}
+			},
+		}
+		sut.Client = &failingClient
+		request := ctrl.Request{
+			NamespacedName: types.NamespacedName{
+				Namespace: "default",
+				Name:      "notGonnaFindIt",
+			},
+		}
+		result, err := sut.Reconcile(context.TODO(), request)
+		It("should return an error", func() {
+			Expect(err).ToNot(BeNil())
+		})
+		It("should requeue the object", func() {
+			Expect(result).To(Equal(ctrl.Result{Requeue: true}))
+		})
+		It("should log that there was an error looking for the project", func() {
+			Expect(log.loggedMessage).To(Equal(errorWhileLookingUpProject))
+		})
+	})
+})
+
+var _ = Describe("getProject", func() {
+	Context("green state", func() {
+		sut, _, _ := getControllerWithMocksInGreenTestState()
+		request := getRequestWithDefaultNamespacedTestProject()
+		project, err := sut.getProject(context.TODO(), request)
+		It("should return a project from the client", func() {
+			Expect(project.Name).To(Equal(request.Name))
+			Expect(project.Namespace).To(Equal(request.Namespace))
+		})
+		It("should return no error", func() {
+			Expect(err).To(BeNil())
+		})
+	})
+	Context("object is not found.", func() {
+		sut, _, _ := getControllerWithMocksInGreenTestState()
+		request := ctrl.Request{
+			NamespacedName: types.NamespacedName{
+				Namespace: "default",
+				Name:      "notGonnaFindIt",
+			},
+		}
+		project, err := sut.getProject(context.TODO(), request)
+		It("should return no project", func() {
+			Expect(project).To(BeNil())
+		})
+		It("should return a not found error.", func() {
+			Expect(err).ToNot(BeNil())
+			Expect(client.IgnoreNotFound(err)).To(BeNil())
+		})
+	})
+	Context("an error occurs", func() {
+		sut, _, _ := getControllerWithMocksInGreenTestState()
+		failingClient := MockClient{
+			GetFunction: func(ctx context.Context, key client.ObjectKey, obj client.Object) error {
+				return &MockError{
+					message: "Error while doing a get.",
+				}
+			},
+		}
+		sut.Client = &failingClient
+		request := ctrl.Request{
+			NamespacedName: types.NamespacedName{
+				Namespace: "default",
+				Name:      "notGonnaFindIt",
+			},
+		}
+		project, err := sut.getProject(context.TODO(), request)
+		It("should return an empty project", func() {
+			Expect(project).ToNot(BeNil())
+		})
+		It("should return an error.", func() {
+			Expect(err).ToNot(BeNil())
+		})
+	})
+})
+
+var _ = Describe("getGroup", func() {
+	Context("green state", func() {
+		
+	})
+})
\ No newline at end of file