Add some meaningful backend and frontend tests

Author: bmo-at-a9s

src/frontend/packages/core/src/shared/components/page-header/page-header.component.spec.ts

@@ -1,4 +1,5 @@
 import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
 import { ActivatedRoute } from '@angular/router';
 import { RouterTestingModule } from '@angular/router/testing';
 import { StoreModule } from '@ngrx/store';
@@ -17,7 +18,16 @@ import { PageHeaderModule } from './page-header.module';
 describe('PageHeaderComponent', () => {
   let component: PageHeaderComponent;
   let fixture: ComponentFixture<PageHeaderComponent>;
+  let httpMock: HttpTestingController;
   const URL_KEY = 'key';
+  const TOKEN_RESPONSE = {
+    data: {
+      auth_token: "auth_token_mock_value",
+      refresh_token: "refresh_token_mock_value",
+      token_expiry: 1753176322,
+    }
+  };
+
   beforeEach(waitForAsync(() => {
     TestBed.configureTestingModule({
       providers: [
@@ -39,6 +49,7 @@ describe('PageHeaderComponent', () => {
         CoreModule,
         SharedModule,
         PageHeaderModule,
+        HttpClientTestingModule,
         RouterTestingModule,
         StoreModule.forRoot(
           appReducers
@@ -51,9 +62,14 @@ describe('PageHeaderComponent', () => {
   beforeEach(() => {
     fixture = TestBed.createComponent(PageHeaderComponent);
     component = fixture.componentInstance;
+    httpMock = TestBed.inject(HttpTestingController);
     fixture.detectChanges();
   });
 
+  afterEach(() => {
+    httpMock.verify();
+  });
+
   it('should be created', () => {
     expect(component).toBeTruthy();
   });
@@ -118,4 +134,43 @@ describe('PageHeaderComponent', () => {
     expect(breadcrumbDefinitions).toBeDefined();
     expect(breadcrumbDefinitions.length).toEqual(2);
   });
+
+  it('should have an auth token', (done) => {
+    component.authToken$.subscribe(data => {
+      expect(data).toEqual(TOKEN_RESPONSE.data.auth_token);
+      done();
+    });
+
+    const req = httpMock.expectOne('/api/v1/auth/token');
+    expect(req.request.method).toBe('GET');
+    req.flush(TOKEN_RESPONSE);
+
+    fixture.detectChanges();
+  })
+
+  it('should have a refresh token', (done) => {
+    component.refreshToken$.subscribe(data => {
+      expect(data).toEqual(TOKEN_RESPONSE.data.refresh_token);
+      done();
+    });
+
+    const req = httpMock.expectOne('/api/v1/auth/token');
+    expect(req.request.method).toBe('GET');
+    req.flush(TOKEN_RESPONSE);
+
+    fixture.detectChanges();
+  })
+
+  it('should have a token expiry', (done) => {
+    component.tokenExpiry$.subscribe(data => {
+      expect(data).toEqual(new Date(TOKEN_RESPONSE.data.token_expiry * 1000));
+      done();
+    });
+
+    const req = httpMock.expectOne('/api/v1/auth/token');
+    expect(req.request.method).toBe('GET');
+    req.flush(TOKEN_RESPONSE);
+
+    fixture.detectChanges();
+  })
 });

src/jetstream/session_test.go

@@ -11,33 +11,101 @@ import (
 	. "github.com/smartystreets/goconvey/convey"
 )
 
+/*
+Portal Proxy mock that errors out when looking for a session
+*/
 type sessionTestPortalProxy struct {
 	portalProxy
 }
 
-type testEchoContext struct {
+func (*sessionTestPortalProxy) GetSession(_ echo.Context) (*sessions.Session, error) {
+	return nil, errors.New("Test error")
+}
+
+/*
+Echo context mock that will make everything work and bypass all session checks
+*/
+type testEchoContextBypass struct {
 	echo.Context
+	JSONResponseVerifier func(statusCode int, input any) error
 }
 
-func (s *testEchoContext) Request() *http.Request {
-	return nil
+func (*testEchoContextBypass) Request() *http.Request {
+	return &http.Request{}
 }
 
-func (s *testEchoContext) Get(key string) interface{} {
+func (*testEchoContextBypass) Get(_ string) any {
 	return nil
 }
 
-func (p *sessionTestPortalProxy) GetSession(c echo.Context) (*sessions.Session, error) {
-	return nil, errors.New("Test error")
+func (*testEchoContextBypass) Set(_ string, _ any) {}
+
+func (c *testEchoContextBypass) JSON(statusCode int, input any) error {
+	return c.JSONResponseVerifier(statusCode, input)
 }
 
-type testSessionStore struct {
+type testSessionStoreFailure struct {
 	api.SessionStorer
 }
 
-func (p *testSessionStore) Get(req *http.Request, name string) (*sessions.Session, error) {
+func (p *testSessionStoreFailure) Get(_ *http.Request, _ string) (*sessions.Session, error) {
 	return nil, errors.New("Test error")
 }
+
+type testSessionStoreSuccessful struct {
+	api.SessionStorer
+}
+
+func (p *testSessionStoreSuccessful) Get(_ *http.Request, _ string) (*sessions.Session, error) {
+	return &sessions.Session{
+		ID: "00000000-0000-0000-0000-000000000001",
+		Values: map[any]any{
+			"exp":     int64(9223372036854775807),
+			"user_id": "mockuid",
+		},
+		Options: &sessions.Options{},
+		IsNew:   false,
+	}, nil
+}
+
+type testStratosAuthService struct {
+	api.StratosAuth
+}
+
+func (s *testStratosAuthService) BeforeVerifySession(c echo.Context) {}
+func (s *testStratosAuthService) VerifySession(c echo.Context, sessionUser string, expiryTime int64) error {
+	return nil
+}
+
+type testStoreFactory struct {
+	api.StoreFactory
+}
+
+func (s *testStoreFactory) TokenStore() (api.TokenRepository, error) {
+	return &testTokenStore{}, nil
+}
+
+type testTokenStore struct {
+	api.TokenRepository
+}
+
+func (s *testTokenStore) FindAuthToken(userGUID string, encryptionKey []byte) (api.TokenRecord, error) {
+	return api.TokenRecord{
+		TokenGUID:      "mockTokenGUID",
+		AuthToken:      "mockAuthToken",
+		RefreshToken:   "mockRefreshToken",
+		TokenExpiry:    1,
+		Disconnected:   false,
+		AuthType:       "mockAuthType",
+		Metadata:       "mockMetadata",
+		SystemShared:   false,
+		LinkedGUID:     "mockLinkedGUID",
+		Certificate:    "mockCertificate",
+		CertificateKey: "mockCertificateKey",
+		Enabled:        false,
+	}, nil
+}
+
 func TestSession(t *testing.T) {
 
 	Convey("Check error struct", t, func() {
@@ -52,10 +120,10 @@ func TestSession(t *testing.T) {
 	Convey("Check error conditions when no session avaialable", t, func() {
 
 		pp := &portalProxy{
-			SessionStore: &testSessionStore{},
+			SessionStore: &testSessionStoreFailure{},
 		}
 
-		ctx := &testEchoContext{}
+		ctx := &testEchoContextBypass{}
 
 		_, err := pp.GetSession(ctx)
 		So(err, ShouldNotBeNil)
@@ -74,4 +142,51 @@ func TestSession(t *testing.T) {
 		So(err, ShouldNotBeNil)
 	})
 
+	Convey("Return the token on request for the current session when session is valid", t, func() {
+		pp := &portalProxy{
+			SessionStore:       &testSessionStoreSuccessful{},
+			StratosAuthService: &testStratosAuthService{},
+			StoreFactory:       &testStoreFactory{},
+		}
+
+		ctx := &testEchoContextBypass{JSONResponseVerifier: func(s int, i any) error {
+			So(s, ShouldEqual, http.StatusOK)
+			t, ok := i.(AuthTokenEnvelope)
+			So(ok, ShouldBeTrue)
+			So(t.Error, ShouldBeEmpty)
+			So(t.Status, ShouldEqual, "ok")
+			So(t.Data.AuthToken, ShouldEqual, "mockAuthToken")
+			So(t.Data.RefreshToken, ShouldEqual, "mockRefreshToken")
+			So(t.Data.TokenExpiry, ShouldEqual, 1)
+
+			return nil
+		}}
+
+		err := pp.retrieveToken(ctx)
+
+		So(err, ShouldBeNil)
+	})
+
+	Convey("Return error message and no token on request if current session is invalid", t, func() {
+		pp := &portalProxy{
+			SessionStore:       &testSessionStoreFailure{},
+			StratosAuthService: &testStratosAuthService{},
+			StoreFactory:       &testStoreFactory{},
+		}
+
+		ctx := &testEchoContextBypass{JSONResponseVerifier: func(s int, i any) error {
+			So(s, ShouldEqual, http.StatusOK)
+			t, ok := i.(AuthTokenEnvelope)
+			So(ok, ShouldBeTrue)
+			So(t.Error, ShouldNotBeBlank)
+			So(t.Status, ShouldEqual, "error")
+			So(t.Data, ShouldBeNil)
+			return nil
+		}}
+
+		err := pp.retrieveToken(ctx)
+
+		So(err, ShouldBeNil)
+	})
+
 }