diff --git a/client/src/components/notifications/index.vue b/client/src/components/notifications/index.vue
index 4784c0daa..9864850f1 100644
--- a/client/src/components/notifications/index.vue
+++ b/client/src/components/notifications/index.vue
@@ -1,7 +1,7 @@
 <template>
   <v-container>
     <v-row>
-      <v-col cols="12" md="12" lg="8">
+      <v-col cols="12" md="12" lg="12" xl="6">
         <v-expansion-panels multiple elevation="0" class="mb-6">
           <v-expansion-panel>
             <v-expansion-panel-title class="text-h6 font-weight-bold">What are Notifications?</v-expansion-panel-title>
diff --git a/client/src/components/podsizes/index.vue b/client/src/components/podsizes/index.vue
index c6e7f9015..f308c3b42 100644
--- a/client/src/components/podsizes/index.vue
+++ b/client/src/components/podsizes/index.vue
@@ -1,7 +1,7 @@
 <template>
   <v-container>
     <v-row>
-      <v-col cols="12" md="12" lg="8">
+      <v-col cols="12" md="12" lg="12" xl="6">
         <v-expansion-panels multiple elevation="0" class="mb-6">
           <v-expansion-panel>
             <v-expansion-panel-title class="text-h6 font-weight-bold">What are PodSizes?</v-expansion-panel-title>
diff --git a/client/src/components/runpacks/index.vue b/client/src/components/runpacks/index.vue
index 6afefd89d..d14b991bb 100644
--- a/client/src/components/runpacks/index.vue
+++ b/client/src/components/runpacks/index.vue
@@ -2,7 +2,7 @@
 
   <v-container>
     <v-row>
-      <v-col cols="12" md="12" lg="8">
+      <v-col cols="12" md="12" lg="12" xl="6">
         <v-expansion-panels multiple elevation="0" class="mb-6">
           <v-expansion-panel>
             <v-expansion-panel-title class="text-h6 font-weight-bold">What are Runpacks?</v-expansion-panel-title>
diff --git a/client/src/layouts/default/NavDrawer.vue b/client/src/layouts/default/NavDrawer.vue
index 0bdec4396..381922b16 100644
--- a/client/src/layouts/default/NavDrawer.vue
+++ b/client/src/layouts/default/NavDrawer.vue
@@ -3,7 +3,7 @@
       color="navBG"
       expand-on-hover
       permanent
-      rail
+      :rail="rail"
   >
     <v-list class="profile-dark-bg">
       <v-list-item
@@ -20,6 +20,20 @@
         <template #subtitle>
           {{ userEmail }}
         </template>
+        <template v-slot:append>
+          <v-btn
+            v-if="rail"
+            icon="mdi-chevron-right"
+            variant="text"
+            @click="rail = false"
+          ></v-btn>
+          <v-btn
+            v-else
+            icon="mdi-chevron-left"
+            variant="text"
+            @click="rail = true"
+          ></v-btn>
+        </template>
       </v-list-item>
     </v-list>
 
@@ -73,23 +87,27 @@
             title="General"
             prepend-icon="mdi-tune"
             density="compact"
+            style="transform: scale(0.9);"
           ></v-list-item>
           <v-list-item 
               link to="/runpacks" 
               v-if="kubero.isAuthenticated && !kubero.adminDisabled"
               prepend-icon="mdi-cube-outline"
+              style="transform: scale(0.9);"
               title="Runpacks">
           </v-list-item>
           <v-list-item 
               link to="/podsizes" 
               v-if="kubero.isAuthenticated && !kubero.adminDisabled"
               prepend-icon="mdi-arrow-expand-vertical"
+              style="transform: scale(0.9);"
               title="Pod Sizes">
           </v-list-item>
           <v-list-item 
               link to="/notifications" 
               v-if="kubero.isAuthenticated && !kubero.adminDisabled"
               prepend-icon="mdi-email-fast-outline"
+              style="transform: scale(0.9);"
               title="Notifications">
           </v-list-item>
         </v-list-group>
@@ -253,6 +271,7 @@ const theme = useTheme()
 const userAvatar = ref<string>('')
 const userName = ref<string>('')
 const userEmail = ref<string>('')
+const rail = ref(true)
 
 async function loadUserProfile() {
   try {
@@ -369,3 +388,9 @@ img.image-icon {
   background: rgba(var(--v-theme-secondary), 0.5) !important;
 }
 </style>
+
+<style>
+.v-list-group__items {
+  --indent-padding: inherit;
+}
+</style>
diff --git a/server/src/config/config.service.spec.ts b/server/src/config/config.service.spec.ts
index 055299a17..5317ee128 100644
--- a/server/src/config/config.service.spec.ts
+++ b/server/src/config/config.service.spec.ts
@@ -1,4 +1,36 @@
 import { ConfigService } from './config.service';
+import { PodSize } from './podsize/podsize';
+import { Runpack } from './buildpack/runpack';
+
+// Mock PrismaClient
+const mockPrismaClient = {
+  runpack: {
+    findMany: jest.fn(),
+    findUnique: jest.fn(),
+    create: jest.fn(),
+    delete: jest.fn(),
+  },
+  podSize: {
+    findMany: jest.fn(),
+    findUnique: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn(),
+  },
+  runpackPhase: {
+    create: jest.fn(),
+  },
+  capabilityAdd: {
+    createMany: jest.fn(),
+  },
+  capabilityDrop: {
+    createMany: jest.fn(),
+  },
+};
+
+jest.mock('@prisma/client', () => ({
+  PrismaClient: jest.fn().mockImplementation(() => mockPrismaClient),
+}));
 
 jest.mock('fs', () => ({
   readFileSync: jest.fn(() => '"1.2.3"'),
@@ -47,6 +79,9 @@ describe('ConfigService', () => {
   let notification: any;
 
   beforeEach(() => {
+    // Clear all mock calls before each test
+    jest.clearAllMocks();
+
     kubectl = {
       getKuberoConfig: jest.fn().mockResolvedValue({
         spec: {
@@ -331,4 +366,489 @@ describe('ConfigService', () => {
     delete process.env.npm_package_version;
     expect(service.getKuberoUIVersion()).toBe('0.0.0');
   });
+
+  describe('getRunpacks', () => {
+    it('should return all runpacks from database', async () => {
+      const mockDbRunpacks = [
+        {
+          id: '1',
+          name: 'nodejs',
+          language: 'javascript',
+          fetch: {
+            id: 'fetch1',
+            repository: 'kubero/fetch',
+            tag: 'latest',
+            command: 'fetch-cmd',
+            readOnlyAppStorage: true,
+            securityContext: {
+              runAsUser: 1000,
+              runAsGroup: 1000,
+              allowPrivilegeEscalation: false,
+              readOnlyRootFilesystem: true,
+              runAsNonRoot: true,
+              capabilities: { add: [], drop: [] },
+            },
+          },
+          build: {
+            id: 'build1',
+            repository: 'kubero/build',
+            tag: 'latest',
+            command: 'build-cmd',
+            readOnlyAppStorage: true,
+            securityContext: {
+              runAsUser: 1000,
+              runAsGroup: 1000,
+              allowPrivilegeEscalation: false,
+              readOnlyRootFilesystem: true,
+              runAsNonRoot: true,
+              capabilities: { add: [], drop: [] },
+            },
+          },
+          run: {
+            id: 'run1',
+            repository: 'kubero/run',
+            tag: 'latest',
+            command: 'run-cmd',
+            readOnlyAppStorage: false,
+            securityContext: {
+              runAsUser: 1000,
+              runAsGroup: 1000,
+              allowPrivilegeEscalation: false,
+              readOnlyRootFilesystem: false,
+              runAsNonRoot: true,
+              capabilities: { add: [], drop: [] },
+            },
+          },
+        },
+      ];
+
+      mockPrismaClient.runpack.findMany.mockResolvedValue(mockDbRunpacks);
+
+      const result = await service.getRunpacks();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBeInstanceOf(Runpack);
+      expect(result[0].name).toBe('nodejs');
+      expect(result[0].language).toBe('javascript');
+      expect(mockPrismaClient.runpack.findMany).toHaveBeenCalledWith({
+        include: { fetch: true, build: true, run: true },
+      });
+    });
+
+    it('should return empty array when no runpacks exist', async () => {
+      mockPrismaClient.runpack.findMany.mockResolvedValue([]);
+
+      const result = await service.getRunpacks();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle database errors', async () => {
+      mockPrismaClient.runpack.findMany.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.getRunpacks()).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('getPodSizes', () => {
+    it('should return all pod sizes from database', async () => {
+      const mockDbPodSizes = [
+        {
+          id: '1',
+          name: 'small',
+          description: 'Small pod size',
+          memoryRequest: '128Mi',
+          cpuRequest: '100m',
+          memoryLimit: '256Mi',
+          cpuLimit: '200m',
+        },
+        {
+          id: '2',
+          name: 'medium',
+          description: 'Medium pod size',
+          memoryRequest: '256Mi',
+          cpuRequest: '200m',
+          memoryLimit: '512Mi',
+          cpuLimit: '400m',
+        },
+      ];
+
+      mockPrismaClient.podSize.findMany.mockResolvedValue(mockDbPodSizes);
+
+      const result = await service.getPodSizes();
+
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(PodSize);
+      expect(result[0].name).toBe('small');
+      expect(result[0].description).toBe('Small pod size');
+      expect(result[0].resources.requests?.memory).toBe('128Mi');
+      expect(result[0].resources.limits?.memory).toBe('256Mi');
+      expect(result[1].name).toBe('medium');
+    });
+
+    it('should return empty array when no pod sizes exist', async () => {
+      mockPrismaClient.podSize.findMany.mockResolvedValue([]);
+
+      const result = await service.getPodSizes();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle database errors', async () => {
+      mockPrismaClient.podSize.findMany.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.getPodSizes()).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('createRunpack', () => {
+    it('should create a new runpack successfully', async () => {
+      const mockRunpackInput = {
+        name: 'python',
+        language: 'python',
+        fetch: {
+          repository: 'kubero/fetch-python',
+          tag: 'latest',
+          command: 'fetch-python-cmd',
+          readOnlyAppStorage: true,
+          securityContext: {
+            runAsUser: 1000,
+            runAsGroup: 1000,
+            allowPrivilegeEscalation: false,
+            readOnlyRootFilesystem: true,
+            runAsNonRoot: true,
+            capabilities: { add: [], drop: ['ALL'] },
+          },
+        },
+        build: {
+          repository: 'kubero/build-python',
+          tag: 'latest',
+          command: 'build-python-cmd',
+          readOnlyAppStorage: true,
+          securityContext: {
+            runAsUser: 1000,
+            runAsGroup: 1000,
+            allowPrivilegeEscalation: false,
+            readOnlyRootFilesystem: true,
+            runAsNonRoot: true,
+            capabilities: { add: [], drop: ['ALL'] },
+          },
+        },
+        run: {
+          repository: 'kubero/run-python',
+          tag: 'latest',
+          command: 'run-python-cmd',
+          readOnlyAppStorage: false,
+          securityContext: {
+            runAsUser: 1000,
+            runAsGroup: 1000,
+            allowPrivilegeEscalation: false,
+            readOnlyRootFilesystem: false,
+            runAsNonRoot: true,
+            capabilities: { add: [], drop: ['ALL'] },
+          },
+        },
+      };
+
+      const mockCreatedPhases = {
+        fetch: { id: 'fetch-id' },
+        build: { id: 'build-id' },
+        run: { id: 'run-id' },
+      };
+
+      const mockCreatedRunpack = {
+        id: 'runpack-id',
+        name: 'python',
+        language: 'python',
+        fetch: mockCreatedPhases.fetch,
+        build: mockCreatedPhases.build,
+        run: mockCreatedPhases.run,
+      };
+
+      mockPrismaClient.runpackPhase.create
+        .mockResolvedValueOnce(mockCreatedPhases.fetch)
+        .mockResolvedValueOnce(mockCreatedPhases.build)
+        .mockResolvedValueOnce(mockCreatedPhases.run);
+
+      mockPrismaClient.capabilityAdd.createMany.mockResolvedValue({});
+      mockPrismaClient.capabilityDrop.createMany.mockResolvedValue({});
+      mockPrismaClient.runpack.create.mockResolvedValue(mockCreatedRunpack);
+
+      const result = await service.createRunpack(mockRunpackInput);
+
+      expect(result).toEqual(mockCreatedRunpack);
+      expect(mockPrismaClient.runpackPhase.create).toHaveBeenCalledTimes(3);
+      expect(mockPrismaClient.runpack.create).toHaveBeenCalledWith({
+        data: {
+          name: 'python',
+          language: 'python',
+          fetch: { connect: { id: 'fetch-id' } },
+          build: { connect: { id: 'build-id' } },
+          run: { connect: { id: 'run-id' } },
+        },
+        include: { fetch: true, build: true, run: true },
+      });
+    });
+  });
+
+  describe('addPodSize', () => {
+    it('should create a new pod size successfully', async () => {
+      const mockPodSize = new PodSize({
+        name: 'large',
+        description: 'Large pod size',
+        resources: {
+          requests: {
+            memory: '512Mi',
+            cpu: '400m',
+          },
+          limits: {
+            memory: '1Gi',
+            cpu: '800m',
+          },
+        },
+      });
+
+      const mockDbPodSize = {
+        id: 'podsize-id',
+        name: 'large',
+        description: 'Large pod size',
+        memoryRequest: '512Mi',
+        cpuRequest: '400m',
+        memoryLimit: '1Gi',
+        cpuLimit: '800m',
+      };
+
+      mockPrismaClient.podSize.create.mockResolvedValue(mockDbPodSize);
+
+      const result = await service.addPodSize(mockPodSize);
+
+      expect(result).toBeInstanceOf(PodSize);
+      expect(result.name).toBe('large');
+      expect(result.description).toBe('Large pod size');
+      expect(result.resources.requests?.memory).toBe('512Mi');
+      expect(result.resources.limits?.memory).toBe('1Gi');
+      
+      expect(mockPrismaClient.podSize.create).toHaveBeenCalledWith({
+        data: {
+          name: 'large',
+          description: 'Large pod size',
+          memoryLimit: '1Gi',
+          cpuLimit: '800m',
+          memoryRequest: '512Mi',
+          cpuRequest: '400m',
+        },
+      });
+    });
+
+    it('should handle empty resource values', async () => {
+      const mockPodSize = new PodSize({
+        name: 'minimal',
+        description: 'Minimal pod size',
+        resources: {},
+      });
+
+      const mockDbPodSize = {
+        id: 'podsize-id',
+        name: 'minimal',
+        description: 'Minimal pod size',
+        memoryRequest: '',
+        cpuRequest: '',
+        memoryLimit: '',
+        cpuLimit: '',
+      };
+
+      mockPrismaClient.podSize.create.mockResolvedValue(mockDbPodSize);
+
+      const result = await service.addPodSize(mockPodSize);
+
+      expect(result).toBeInstanceOf(PodSize);
+      expect(mockPrismaClient.podSize.create).toHaveBeenCalledWith({
+        data: {
+          name: 'minimal',
+          description: 'Minimal pod size',
+          memoryLimit: '',
+          cpuLimit: '',
+          memoryRequest: '',
+          cpuRequest: '',
+        },
+      });
+    });
+
+    it('should handle database errors during pod size creation', async () => {
+      const mockPodSize = new PodSize({
+        name: 'test',
+        description: 'Test pod size',
+        resources: {},
+      });
+
+      mockPrismaClient.podSize.create.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.addPodSize(mockPodSize)).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('updatePodSize', () => {
+    it('should update an existing pod size successfully', async () => {
+      const podSizeId = 'existing-id';
+      const mockPodSize = new PodSize({
+        name: 'updated-large',
+        description: 'Updated large pod size',
+        resources: {
+          requests: {
+            memory: '1Gi',
+            cpu: '500m',
+          },
+          limits: {
+            memory: '2Gi',
+            cpu: '1000m',
+          },
+        },
+      });
+
+      const mockUpdatedDbPodSize = {
+        id: podSizeId,
+        name: 'updated-large',
+        description: 'Updated large pod size',
+        memoryRequest: '1Gi',
+        cpuRequest: '500m',
+        memoryLimit: '2Gi',
+        cpuLimit: '1000m',
+      };
+
+      mockPrismaClient.podSize.update.mockResolvedValue(mockUpdatedDbPodSize);
+
+      const result = await service.updatePodSize(podSizeId, mockPodSize);
+
+      expect(result).toBeInstanceOf(PodSize);
+      expect(result.name).toBe('updated-large');
+      expect(result.description).toBe('Updated large pod size');
+      expect(result.resources.requests?.memory).toBe('1Gi');
+      expect(result.resources.limits?.memory).toBe('2Gi');
+      
+      expect(mockPrismaClient.podSize.update).toHaveBeenCalledWith({
+        where: { id: podSizeId },
+        data: {
+          name: 'updated-large',
+          description: 'Updated large pod size',
+          memoryLimit: '2Gi',
+          cpuLimit: '1000m',
+          memoryRequest: '1Gi',
+          cpuRequest: '500m',
+        },
+      });
+    });
+
+    it('should handle database errors during pod size update', async () => {
+      const mockPodSize = new PodSize({
+        name: 'test',
+        description: 'Test pod size',
+        resources: {},
+      });
+
+      mockPrismaClient.podSize.update.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.updatePodSize('test-id', mockPodSize)).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('deletePodSize', () => {
+    it('should delete an existing pod size successfully', async () => {
+      const podSizeId = 'existing-id';
+      const mockPodSize = {
+        id: podSizeId,
+        name: 'to-delete',
+        description: 'Pod size to delete',
+      };
+
+      mockPrismaClient.podSize.findUnique.mockResolvedValue(mockPodSize);
+      mockPrismaClient.podSize.delete.mockResolvedValue(mockPodSize);
+
+      await service.deletePodSize(podSizeId);
+
+      expect(mockPrismaClient.podSize.findUnique).toHaveBeenCalledWith({
+        where: { id: podSizeId },
+      });
+      expect(mockPrismaClient.podSize.delete).toHaveBeenCalledWith({
+        where: { id: podSizeId },
+      });
+    });
+
+    it('should throw error when pod size not found', async () => {
+      const podSizeId = 'non-existing-id';
+
+      mockPrismaClient.podSize.findUnique.mockResolvedValue(null);
+
+      await expect(service.deletePodSize(podSizeId)).rejects.toThrow(
+        `PodSize with id ${podSizeId} not found`
+      );
+
+      expect(mockPrismaClient.podSize.delete).not.toHaveBeenCalled();
+    });
+
+    it('should handle database errors during pod size deletion', async () => {
+      const podSizeId = 'existing-id';
+      const mockPodSize = { id: podSizeId, name: 'test' };
+
+      mockPrismaClient.podSize.findUnique.mockResolvedValue(mockPodSize);
+      mockPrismaClient.podSize.delete.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.deletePodSize(podSizeId)).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('deleteRunpack', () => {
+    it('should delete an existing runpack successfully', async () => {
+      const runpackId = 'existing-runpack-id';
+      const mockRunpack = {
+        id: runpackId,
+        name: 'nodejs-to-delete',
+      };
+
+      mockPrismaClient.runpack.findUnique.mockResolvedValue(mockRunpack);
+      mockPrismaClient.runpack.delete.mockResolvedValue(mockRunpack);
+
+      await service.deleteRunpack(runpackId);
+
+      expect(mockPrismaClient.runpack.findUnique).toHaveBeenCalledWith({
+        where: { id: runpackId },
+      });
+      expect(mockPrismaClient.runpack.delete).toHaveBeenCalledWith({
+        where: { id: runpackId },
+      });
+      expect(notification.send).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: 'deleteRunpack',
+          action: 'delete',
+          message: 'Runpack nodejs-to-delete deleted',
+          data: {
+            runpackId,
+            runpackName: 'nodejs-to-delete',
+          },
+        })
+      );
+    });
+
+    it('should throw error when runpack not found', async () => {
+      const runpackId = 'non-existing-runpack-id';
+
+      mockPrismaClient.runpack.findUnique.mockResolvedValue(null);
+
+      await expect(service.deleteRunpack(runpackId)).rejects.toThrow(
+        `Runpack with id ${runpackId} not found`
+      );
+
+      expect(mockPrismaClient.runpack.delete).not.toHaveBeenCalled();
+      expect(notification.send).not.toHaveBeenCalled();
+    });
+
+    it('should handle database errors during runpack deletion', async () => {
+      const runpackId = 'existing-runpack-id';
+      const mockRunpack = { id: runpackId, name: 'test-runpack' };
+
+      mockPrismaClient.runpack.findUnique.mockResolvedValue(mockRunpack);
+      mockPrismaClient.runpack.delete.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.deleteRunpack(runpackId)).rejects.toThrow('Database error');
+    });
+  });
 });
diff --git a/server/src/kubernetes/kubernetes.service.spec.ts b/server/src/kubernetes/kubernetes.service.spec.ts
index 3c78e28c5..d1cbe260b 100644
--- a/server/src/kubernetes/kubernetes.service.spec.ts
+++ b/server/src/kubernetes/kubernetes.service.spec.ts
@@ -212,7 +212,114 @@ describe('KubernetesService', () => {
   });
 
   it('should getPodUptimes', async () => {
-    await expect(service.getPodUptimes('ns')).resolves.toBeDefined();
+    const mockPods = {
+      body: {
+        items: [
+          {
+            metadata: { name: 'pod1' },
+            status: { startTime: new Date(Date.now() - 60000) } // 1 minute ago
+          },
+          {
+            metadata: { name: 'pod2' },
+            status: { startTime: new Date(Date.now() - 3600000) } // 1 hour ago
+          },
+          {
+            metadata: { name: 'pod3' },
+            status: {} // no startTime
+          },
+          {
+            metadata: {} // no name
+          }
+        ]
+      }
+    };
+
+    // Access the mocked coreV1Api through the service
+    const coreV1ApiMock = (service as any).coreV1Api;
+    coreV1ApiMock.listNamespacedPod.mockResolvedValue(mockPods);
+
+    const result = await service.getPodUptimes('test-namespace');
+
+    expect(coreV1ApiMock.listNamespacedPod).toHaveBeenCalledWith('test-namespace');
+    expect(result).toBeDefined();
+    expect(result['pod1']).toBeDefined();
+    expect(result['pod1'].ms).toBeGreaterThan(50000); // roughly 1 minute in ms
+    expect(result['pod1'].formatted).toBeDefined();
+    expect(result['pod2']).toBeDefined();
+    expect(result['pod2'].ms).toBeGreaterThan(3500000); // roughly 1 hour in ms
+    expect(result['pod2'].formatted).toBeDefined();
+    expect(result['pod3']).toBeDefined();
+    expect(result['pod3'].ms).toBe(-1);
+    expect(result['pod3'].formatted).toBe('');
+  });
+
+  describe('getPodUptimeMS', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should return -1 when startTime is not provided', () => {
+      const pod = {
+        status: {}
+      };
+
+      const uptime = (service as any).getPodUptimeMS(pod);
+      expect(uptime).toBe(-1);
+    });
+
+    it('should return -1 when status is not provided', () => {
+      const pod = {};
+
+      const uptime = (service as any).getPodUptimeMS(pod);
+      expect(uptime).toBe(-1);
+    });
+  });
+
+  describe('formatUptime', () => {
+    it('should return empty string for negative uptime', () => {
+      const result = (service as any).formatUptime(-1);
+      expect(result).toBe('');
+    });
+
+    it('should format seconds for uptime < 120s', () => {
+      expect((service as any).formatUptime(5000)).toBe('5s');
+      expect((service as any).formatUptime(59000)).toBe('59s');
+      expect((service as any).formatUptime(119000)).toBe('119s');
+    });
+
+    it('should format minutes and seconds for 2-10 minutes', () => {
+      expect((service as any).formatUptime(120000)).toBe('2m');
+      expect((service as any).formatUptime(125000)).toBe('2m5s');
+      expect((service as any).formatUptime(300000)).toBe('5m');
+      expect((service as any).formatUptime(315000)).toBe('5m15s');
+      expect((service as any).formatUptime(599000)).toBe('9m59s');
+    });
+
+    it('should format only minutes for 10-120 minutes', () => {
+      expect((service as any).formatUptime(600000)).toBe('10m');
+      expect((service as any).formatUptime(1800000)).toBe('30m');
+      expect((service as any).formatUptime(7199000)).toBe('119m');
+    });
+
+    it('should format hours and minutes for 2-48 hours', () => {
+      expect((service as any).formatUptime(7200000)).toBe('2h');
+      expect((service as any).formatUptime(7500000)).toBe('2h5m');
+      expect((service as any).formatUptime(86400000)).toBe('24h');
+      expect((service as any).formatUptime(90000000)).toBe('25h');
+      expect((service as any).formatUptime(172799000)).toBe('47h59m');
+    });
+
+    it('should format days and hours for longer periods', () => {
+      expect((service as any).formatUptime(172800000)).toBe('2d');
+      expect((service as any).formatUptime(176400000)).toBe('2d1h');
+      expect((service as any).formatUptime(259200000)).toBe('3d');
+      expect((service as any).formatUptime(694800000)).toBe('8d1h');
+      expect((service as any).formatUptime(2592000000)).toBe('30d');
+    });
   });
 
   it('should getStorageClasses', async () => {
diff --git a/server/src/notifications/notifications-db.service.spec.ts b/server/src/notifications/notifications-db.service.spec.ts
new file mode 100644
index 000000000..74ccf5215
--- /dev/null
+++ b/server/src/notifications/notifications-db.service.spec.ts
@@ -0,0 +1,530 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { NotificationsDbService, CreateNotificationDto, NotificationDb } from './notifications-db.service';
+import { INotificationConfig } from './notifications.interface';
+import { PrismaClient } from '@prisma/client';
+
+// Mock PrismaClient
+const mockPrismaClient = {
+  notification: {
+    findMany: jest.fn(),
+    findUnique: jest.fn(),
+    findFirst: jest.fn(),
+    create: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn(),
+  },
+};
+
+jest.mock('@prisma/client', () => ({
+  PrismaClient: jest.fn().mockImplementation(() => mockPrismaClient),
+}));
+
+describe('NotificationsDbService', () => {
+  let service: NotificationsDbService;
+  let prisma: any;
+
+  const mockNotificationDb: NotificationDb = {
+    id: '123e4567-e89b-12d3-a456-426614174000',
+    name: 'Test Notification',
+    enabled: true,
+    type: 'slack',
+    pipelines: '["pipeline1", "pipeline2"]',
+    events: '["deploy", "build"]',
+    webhookUrl: null,
+    webhookSecret: null,
+    slackUrl: 'https://hooks.slack.com/test',
+    slackChannel: '#general',
+    discordUrl: null,
+    createdAt: new Date('2023-01-01T00:00:00Z'),
+    updatedAt: new Date('2023-01-01T00:00:00Z'),
+  };
+
+  const mockCreateNotificationDto: CreateNotificationDto = {
+    name: 'Test Notification',
+    enabled: true,
+    type: 'slack',
+    pipelines: ['pipeline1', 'pipeline2'],
+    events: ['deploy', 'build'],
+    config: {
+      url: 'https://hooks.slack.com/test',
+      channel: '#general',
+    },
+  };
+
+  const mockNotificationConfig: INotificationConfig = {
+    id: '123e4567-e89b-12d3-a456-426614174000',
+    name: 'Test Notification',
+    enabled: true,
+    type: 'slack',
+    pipelines: ['pipeline1', 'pipeline2'],
+    events: ['deploy', 'build'],
+    config: {
+      url: 'https://hooks.slack.com/test',
+      channel: '#general',
+    },
+  };
+
+  beforeEach(async () => {
+    // Clear all mock calls before each test
+    jest.clearAllMocks();
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [NotificationsDbService],
+    }).compile();
+
+    service = module.get<NotificationsDbService>(NotificationsDbService);
+    prisma = mockPrismaClient;
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('findAll', () => {
+    it('should return all notifications ordered by createdAt desc', async () => {
+      const notifications = [mockNotificationDb];
+      prisma.notification.findMany.mockResolvedValue(notifications);
+
+      const result = await service.findAll();
+
+      expect(result).toEqual(notifications);
+      expect(prisma.notification.findMany).toHaveBeenCalledWith({
+        orderBy: { createdAt: 'desc' },
+      });
+    });
+
+    it('should return empty array when no notifications exist', async () => {
+      prisma.notification.findMany.mockResolvedValue([]);
+
+      const result = await service.findAll();
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle database errors', async () => {
+      prisma.notification.findMany.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.findAll()).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('findById', () => {
+    const notificationId = '123e4567-e89b-12d3-a456-426614174000';
+
+    it('should return notification by id', async () => {
+      prisma.notification.findUnique.mockResolvedValue(mockNotificationDb);
+
+      const result = await service.findById(notificationId);
+
+      expect(result).toEqual(mockNotificationDb);
+      expect(prisma.notification.findUnique).toHaveBeenCalledWith({
+        where: { id: notificationId },
+      });
+    });
+
+    it('should return null when notification not found', async () => {
+      prisma.notification.findUnique.mockResolvedValue(null);
+
+      const result = await service.findById(notificationId);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle database errors', async () => {
+      prisma.notification.findUnique.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.findById(notificationId)).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('create', () => {
+    it('should create a slack notification successfully', async () => {
+      const createDto = mockCreateNotificationDto;
+      prisma.notification.create.mockResolvedValue(mockNotificationDb);
+
+      const result = await service.create(createDto);
+
+      expect(result).toEqual(mockNotificationDb);
+      expect(prisma.notification.create).toHaveBeenCalledWith({
+        data: {
+          name: createDto.name,
+          enabled: createDto.enabled,
+          type: createDto.type,
+          pipelines: JSON.stringify(createDto.pipelines),
+          events: JSON.stringify(createDto.events),
+          slackUrl: createDto.config.url,
+          slackChannel: createDto.config.channel,
+        },
+      });
+    });
+
+    it('should create a webhook notification successfully', async () => {
+      const webhookDto: CreateNotificationDto = {
+        name: 'Webhook Notification',
+        enabled: true,
+        type: 'webhook',
+        pipelines: ['pipeline1'],
+        events: ['deploy'],
+        config: {
+          url: 'https://webhook.example.com',
+          secret: 'secret123',
+        },
+      };
+
+      const webhookNotificationDb = {
+        ...mockNotificationDb,
+        type: 'webhook' as const,
+        webhookUrl: 'https://webhook.example.com',
+        webhookSecret: 'secret123',
+        slackUrl: null,
+        slackChannel: null,
+      };
+
+      prisma.notification.create.mockResolvedValue(webhookNotificationDb);
+
+      const result = await service.create(webhookDto);
+
+      expect(result).toEqual(webhookNotificationDb);
+      expect(prisma.notification.create).toHaveBeenCalledWith({
+        data: {
+          name: webhookDto.name,
+          enabled: webhookDto.enabled,
+          type: webhookDto.type,
+          pipelines: JSON.stringify(webhookDto.pipelines),
+          events: JSON.stringify(webhookDto.events),
+          webhookUrl: webhookDto.config.url,
+          webhookSecret: webhookDto.config.secret,
+        },
+      });
+    });
+
+    it('should create a discord notification successfully', async () => {
+      const discordDto: CreateNotificationDto = {
+        name: 'Discord Notification',
+        enabled: true,
+        type: 'discord',
+        pipelines: ['pipeline1'],
+        events: ['deploy'],
+        config: {
+          url: 'https://discord.com/api/webhooks/test',
+        },
+      };
+
+      const discordNotificationDb = {
+        ...mockNotificationDb,
+        type: 'discord' as const,
+        discordUrl: 'https://discord.com/api/webhooks/test',
+        slackUrl: null,
+        slackChannel: null,
+      };
+
+      prisma.notification.create.mockResolvedValue(discordNotificationDb);
+
+      const result = await service.create(discordDto);
+
+      expect(result).toEqual(discordNotificationDb);
+      expect(prisma.notification.create).toHaveBeenCalledWith({
+        data: {
+          name: discordDto.name,
+          enabled: discordDto.enabled,
+          type: discordDto.type,
+          pipelines: JSON.stringify(discordDto.pipelines),
+          events: JSON.stringify(discordDto.events),
+          discordUrl: discordDto.config.url,
+        },
+      });
+    });
+
+    it('should handle database errors during creation', async () => {
+      prisma.notification.create.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.create(mockCreateNotificationDto)).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('update', () => {
+    const notificationId = '123e4567-e89b-12d3-a456-426614174000';
+
+    it('should update notification fields successfully', async () => {
+      const updateData = {
+        name: 'Updated Notification',
+        enabled: false,
+      };
+
+      const updatedNotification = {
+        ...mockNotificationDb,
+        ...updateData,
+      };
+
+      prisma.notification.update.mockResolvedValue(updatedNotification);
+
+      const result = await service.update(notificationId, updateData);
+
+      expect(result).toEqual(updatedNotification);
+      expect(prisma.notification.update).toHaveBeenCalledWith({
+        where: { id: notificationId },
+        data: updateData,
+      });
+    });
+
+    it('should update notification with config and type', async () => {
+      const updateData = {
+        type: 'webhook' as const,
+        config: {
+          url: 'https://new-webhook.example.com',
+          secret: 'newsecret',
+        },
+      };
+
+      const updatedNotification = {
+        ...mockNotificationDb,
+        type: 'webhook' as const,
+        webhookUrl: 'https://new-webhook.example.com',
+        webhookSecret: 'newsecret',
+        slackUrl: null,
+        slackChannel: null,
+        discordUrl: null,
+      };
+
+      prisma.notification.update.mockResolvedValue(updatedNotification);
+
+      const result = await service.update(notificationId, updateData);
+
+      expect(result).toEqual(updatedNotification);
+      expect(prisma.notification.update).toHaveBeenCalledWith({
+        where: { id: notificationId },
+        data: {
+          type: updateData.type,
+          webhookUrl: updateData.config.url,
+          webhookSecret: updateData.config.secret,
+          slackUrl: null,
+          slackChannel: null,
+          discordUrl: null,
+        },
+      });
+    });
+
+    it('should update pipelines and events as JSON strings', async () => {
+      const updateData = {
+        pipelines: ['new-pipeline1', 'new-pipeline2'],
+        events: ['new-event1', 'new-event2'],
+      };
+
+      const updatedNotification = {
+        ...mockNotificationDb,
+        pipelines: JSON.stringify(updateData.pipelines),
+        events: JSON.stringify(updateData.events),
+      };
+
+      prisma.notification.update.mockResolvedValue(updatedNotification);
+
+      const result = await service.update(notificationId, updateData);
+
+      expect(result).toEqual(updatedNotification);
+      expect(prisma.notification.update).toHaveBeenCalledWith({
+        where: { id: notificationId },
+        data: {
+          pipelines: JSON.stringify(updateData.pipelines),
+          events: JSON.stringify(updateData.events),
+        },
+      });
+    });
+
+    it('should handle database errors during update', async () => {
+      prisma.notification.update.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.update(notificationId, { name: 'Updated' })).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('delete', () => {
+    const notificationId = '123e4567-e89b-12d3-a456-426614174000';
+
+    it('should delete notification successfully', async () => {
+      prisma.notification.findUnique.mockResolvedValue(mockNotificationDb);
+      prisma.notification.delete.mockResolvedValue(mockNotificationDb);
+
+      await service.delete(notificationId);
+
+      expect(prisma.notification.findUnique).toHaveBeenCalledWith({
+        where: { id: notificationId },
+      });
+      expect(prisma.notification.delete).toHaveBeenCalledWith({
+        where: { id: notificationId },
+      });
+    });
+
+    it('should throw error when notification not found', async () => {
+      prisma.notification.findUnique.mockResolvedValue(null);
+
+      await expect(service.delete(notificationId)).rejects.toThrow(
+        `Notification with id ${notificationId} not found`
+      );
+      expect(prisma.notification.delete).not.toHaveBeenCalled();
+    });
+
+    it('should handle database errors during deletion', async () => {
+      prisma.notification.findUnique.mockResolvedValue(mockNotificationDb);
+      prisma.notification.delete.mockRejectedValue(new Error('Database error'));
+
+      await expect(service.delete(notificationId)).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('toNotificationConfig', () => {
+    it('should convert slack notification to config format', () => {
+      const result = service.toNotificationConfig(mockNotificationDb);
+
+      expect(result).toEqual(mockNotificationConfig);
+    });
+
+    it('should convert webhook notification to config format', () => {
+      const webhookNotificationDb = {
+        ...mockNotificationDb,
+        type: 'webhook' as const,
+        webhookUrl: 'https://webhook.example.com',
+        webhookSecret: 'secret123',
+        slackUrl: null,
+        slackChannel: null,
+      };
+
+      const expectedConfig = {
+        ...mockNotificationConfig,
+        type: 'webhook' as const,
+        config: {
+          url: 'https://webhook.example.com',
+          secret: 'secret123',
+        },
+      };
+
+      const result = service.toNotificationConfig(webhookNotificationDb);
+
+      expect(result).toEqual(expectedConfig);
+    });
+
+    it('should convert discord notification to config format', () => {
+      const discordNotificationDb = {
+        ...mockNotificationDb,
+        type: 'discord' as const,
+        discordUrl: 'https://discord.com/api/webhooks/test',
+        slackUrl: null,
+        slackChannel: null,
+      };
+
+      const expectedConfig = {
+        ...mockNotificationConfig,
+        type: 'discord' as const,
+        config: {
+          url: 'https://discord.com/api/webhooks/test',
+        },
+      };
+
+      const result = service.toNotificationConfig(discordNotificationDb);
+
+      expect(result).toEqual(expectedConfig);
+    });
+
+    it('should parse JSON strings for pipelines and events', () => {
+      const notificationWithComplexData = {
+        ...mockNotificationDb,
+        pipelines: '["pipeline1", "pipeline2", "pipeline3"]',
+        events: '["deploy", "build", "test"]',
+      };
+
+      const result = service.toNotificationConfig(notificationWithComplexData);
+
+      expect(result.pipelines).toEqual(['pipeline1', 'pipeline2', 'pipeline3']);
+      expect(result.events).toEqual(['deploy', 'build', 'test']);
+    });
+  });
+
+  describe('getNotificationConfigs', () => {
+    it('should return all notifications in config format', async () => {
+      const notifications = [mockNotificationDb];
+      prisma.notification.findMany.mockResolvedValue(notifications);
+
+      const result = await service.getNotificationConfigs();
+
+      expect(result).toEqual([mockNotificationConfig]);
+      expect(prisma.notification.findMany).toHaveBeenCalledWith({
+        orderBy: { createdAt: 'desc' },
+      });
+    });
+
+    it('should return empty array when no notifications exist', async () => {
+      prisma.notification.findMany.mockResolvedValue([]);
+
+      const result = await service.getNotificationConfigs();
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('migrateFromConfig', () => {
+    const configNotifications: INotificationConfig[] = [
+      mockNotificationConfig,
+      {
+        name: 'Webhook Config',
+        enabled: true,
+        type: 'webhook',
+        pipelines: ['pipeline1'],
+        events: ['deploy'],
+        config: {
+          url: 'https://webhook.example.com',
+          secret: 'secret123',
+        },
+      },
+    ];
+
+    it('should migrate notifications from config successfully', async () => {
+      prisma.notification.findFirst
+        .mockResolvedValueOnce(null) // First notification doesn't exist
+        .mockResolvedValueOnce(null); // Second notification doesn't exist
+
+      prisma.notification.create
+        .mockResolvedValueOnce(mockNotificationDb)
+        .mockResolvedValueOnce({
+          ...mockNotificationDb,
+          name: 'Webhook Config',
+          type: 'webhook',
+        });
+
+      await service.migrateFromConfig(configNotifications);
+
+      expect(prisma.notification.findFirst).toHaveBeenCalledTimes(2);
+      expect(prisma.notification.create).toHaveBeenCalledTimes(2);
+    });
+
+    it('should skip existing notifications during migration', async () => {
+      prisma.notification.findFirst
+        .mockResolvedValueOnce(mockNotificationDb) // First notification exists
+        .mockResolvedValueOnce(null); // Second notification doesn't exist
+
+      prisma.notification.create.mockResolvedValueOnce({
+        ...mockNotificationDb,
+        name: 'Webhook Config',
+        type: 'webhook',
+      });
+
+      await service.migrateFromConfig(configNotifications);
+
+      expect(prisma.notification.findFirst).toHaveBeenCalledTimes(2);
+      expect(prisma.notification.create).toHaveBeenCalledTimes(1);
+    });
+
+    it('should handle errors during migration gracefully', async () => {
+      prisma.notification.findFirst
+        .mockResolvedValueOnce(null)
+        .mockResolvedValueOnce(null);
+
+      prisma.notification.create
+        .mockRejectedValueOnce(new Error('Creation failed'))
+        .mockResolvedValueOnce(mockNotificationDb);
+
+      // Should not throw, but handle errors gracefully
+      await expect(service.migrateFromConfig(configNotifications)).resolves.not.toThrow();
+
+      expect(prisma.notification.create).toHaveBeenCalledTimes(2);
+    });
+  });
+});
diff --git a/server/src/notifications/notifications.controller.spec.ts b/server/src/notifications/notifications.controller.spec.ts
new file mode 100644
index 000000000..e7dd7ae81
--- /dev/null
+++ b/server/src/notifications/notifications.controller.spec.ts
@@ -0,0 +1,373 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { HttpException, HttpStatus } from '@nestjs/common';
+import { NotificationsController } from './notifications.controller';
+import { NotificationsDbService, CreateNotificationDto, UpdateNotificationDto } from './notifications-db.service';
+import { INotificationConfig } from './notifications.interface';
+
+describe('NotificationsController', () => {
+  let controller: NotificationsController;
+  let service: jest.Mocked<NotificationsDbService>;
+
+  const mockNotificationConfig: INotificationConfig = {
+    id: '123',
+    name: 'Test Notification',
+    enabled: true,
+    type: 'slack',
+    pipelines: ['pipeline1', 'pipeline2'],
+    events: ['deploy', 'build'],
+    config: {
+      url: 'https://hooks.slack.com/test',
+      channel: '#general',
+    },
+  };
+
+  const mockNotificationDb = {
+    id: '123',
+    name: 'Test Notification',
+    enabled: true,
+    type: 'slack' as const,
+    pipelines: '["pipeline1", "pipeline2"]',
+    events: '["deploy", "build"]',
+    webhookUrl: null,
+    webhookSecret: null,
+    slackUrl: 'https://hooks.slack.com/test',
+    slackChannel: '#general',
+    discordUrl: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  beforeEach(async () => {
+    const mockService = {
+      getNotificationConfigs: jest.fn(),
+      findById: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn(),
+      toNotificationConfig: jest.fn(),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [NotificationsController],
+      providers: [
+        {
+          provide: NotificationsDbService,
+          useValue: mockService,
+        },
+      ],
+    }).compile();
+
+    controller = module.get<NotificationsController>(NotificationsController);
+    service = module.get(NotificationsDbService);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+
+  describe('findAll', () => {
+    it('should return all notifications successfully', async () => {
+      const mockNotifications = [mockNotificationConfig];
+      service.getNotificationConfigs.mockResolvedValue(mockNotifications);
+
+      const result = await controller.findAll();
+
+      expect(result).toEqual({
+        success: true,
+        data: mockNotifications,
+      });
+      expect(service.getNotificationConfigs).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw HttpException when service fails', async () => {
+      service.getNotificationConfigs.mockRejectedValue(new Error('Database error'));
+
+      await expect(controller.findAll()).rejects.toThrow(
+        new HttpException('Failed to fetch notifications', HttpStatus.INTERNAL_SERVER_ERROR)
+      );
+    });
+  });
+
+  describe('findOne', () => {
+    const notificationId = '123';
+
+    it('should return a notification by id successfully', async () => {
+      service.findById.mockResolvedValue(mockNotificationDb);
+      service.toNotificationConfig.mockReturnValue(mockNotificationConfig);
+
+      const result = await controller.findOne(notificationId);
+
+      expect(result).toEqual({
+        success: true,
+        data: mockNotificationConfig,
+      });
+      expect(service.findById).toHaveBeenCalledWith(notificationId);
+      expect(service.toNotificationConfig).toHaveBeenCalledWith(mockNotificationDb);
+    });
+
+    it('should throw NotFound when notification does not exist', async () => {
+      service.findById.mockResolvedValue(null);
+
+      await expect(controller.findOne(notificationId)).rejects.toThrow(
+        new HttpException('Notification not found', HttpStatus.NOT_FOUND)
+      );
+    });
+
+    it('should re-throw HttpException from service', async () => {
+      const httpError = new HttpException('Service error', HttpStatus.BAD_REQUEST);
+      service.findById.mockRejectedValue(httpError);
+
+      await expect(controller.findOne(notificationId)).rejects.toThrow(httpError);
+    });
+
+    it('should throw Internal Server Error for other errors', async () => {
+      service.findById.mockRejectedValue(new Error('Database error'));
+
+      await expect(controller.findOne(notificationId)).rejects.toThrow(
+        new HttpException('Failed to fetch notification', HttpStatus.INTERNAL_SERVER_ERROR)
+      );
+    });
+  });
+
+  describe('create', () => {
+    const createDto: CreateNotificationDto = {
+      name: 'New Notification',
+      enabled: true,
+      type: 'slack',
+      pipelines: ['pipeline1'],
+      events: ['deploy'],
+      config: {
+        url: 'https://hooks.slack.com/test',
+        channel: '#general',
+      },
+    };
+
+    it('should create a notification successfully', async () => {
+      service.create.mockResolvedValue(mockNotificationDb);
+      service.toNotificationConfig.mockReturnValue(mockNotificationConfig);
+
+      const result = await controller.create(createDto);
+
+      expect(result).toEqual({
+        success: true,
+        data: mockNotificationConfig,
+        message: 'Notification created successfully',
+      });
+      expect(service.create).toHaveBeenCalledWith(createDto);
+    });
+
+    it('should throw BadRequest when name is missing', async () => {
+      const invalidDto = { ...createDto, name: '' };
+
+      await expect(controller.create(invalidDto)).rejects.toThrow(
+        new HttpException('Name and type are required fields', HttpStatus.BAD_REQUEST)
+      );
+    });
+
+    it('should throw BadRequest when type is missing', async () => {
+      const invalidDto = { ...createDto, type: undefined as any };
+
+      await expect(controller.create(invalidDto)).rejects.toThrow(
+        new HttpException('Name and type are required fields', HttpStatus.BAD_REQUEST)
+      );
+    });
+
+    it('should throw BadRequest for invalid notification type', async () => {
+      const invalidDto = { ...createDto, type: 'invalid' as any };
+
+      await expect(controller.create(invalidDto)).rejects.toThrow(
+        new HttpException('Invalid notification type. Must be slack, webhook, or discord', HttpStatus.BAD_REQUEST)
+      );
+    });
+
+    it('should throw BadRequest when slack config is missing URL', async () => {
+      const invalidDto = {
+        ...createDto,
+        type: 'slack' as const,
+        config: { channel: '#general' },
+      };
+
+      await expect(controller.create(invalidDto)).rejects.toThrow(
+        new HttpException('Slack notifications require a webhook URL', HttpStatus.BAD_REQUEST)
+      );
+    });
+
+    it('should throw BadRequest when webhook config is missing URL', async () => {
+      const invalidDto = {
+        ...createDto,
+        type: 'webhook' as const,
+        config: { secret: 'secret' },
+      };
+
+      await expect(controller.create(invalidDto)).rejects.toThrow(
+        new HttpException('Webhook notifications require a URL', HttpStatus.BAD_REQUEST)
+      );
+    });
+
+    it('should throw BadRequest when discord config is missing URL', async () => {
+      const invalidDto = {
+        ...createDto,
+        type: 'discord' as const,
+        config: {},
+      };
+
+      await expect(controller.create(invalidDto)).rejects.toThrow(
+        new HttpException('Discord notifications require a webhook URL', HttpStatus.BAD_REQUEST)
+      );
+    });
+
+    it('should re-throw HttpException from service', async () => {
+      const httpError = new HttpException('Service error', HttpStatus.BAD_REQUEST);
+      service.create.mockRejectedValue(httpError);
+
+      await expect(controller.create(createDto)).rejects.toThrow(httpError);
+    });
+
+    it('should throw Internal Server Error for other errors', async () => {
+      service.create.mockRejectedValue(new Error('Database error'));
+
+      await expect(controller.create(createDto)).rejects.toThrow(
+        new HttpException('Failed to create notification', HttpStatus.INTERNAL_SERVER_ERROR)
+      );
+    });
+  });
+
+  describe('update', () => {
+    const notificationId = '123';
+    const updateDto: Partial<CreateNotificationDto> = {
+      name: 'Updated Notification',
+      enabled: false,
+    };
+
+    it('should update a notification successfully', async () => {
+      const updatedNotificationDb = {
+        ...mockNotificationDb,
+        name: updateDto.name || mockNotificationDb.name,
+        enabled: updateDto.enabled !== undefined ? updateDto.enabled : mockNotificationDb.enabled,
+      };
+      const updatedNotificationConfig = {
+        ...mockNotificationConfig,
+        name: updateDto.name || mockNotificationConfig.name,
+        enabled: updateDto.enabled !== undefined ? updateDto.enabled : mockNotificationConfig.enabled,
+      };
+
+      service.findById.mockResolvedValue(mockNotificationDb);
+      service.update.mockResolvedValue(updatedNotificationDb);
+      service.toNotificationConfig.mockReturnValue(updatedNotificationConfig);
+
+      const result = await controller.update(notificationId, updateDto);
+
+      expect(result).toEqual({
+        success: true,
+        data: updatedNotificationConfig,
+        message: 'Notification updated successfully',
+      });
+      expect(service.findById).toHaveBeenCalledWith(notificationId);
+      expect(service.update).toHaveBeenCalledWith(notificationId, updateDto);
+    });
+
+    it('should throw NotFound when notification does not exist', async () => {
+      service.findById.mockResolvedValue(null);
+
+      await expect(controller.update(notificationId, updateDto)).rejects.toThrow(
+        new HttpException('Notification not found', HttpStatus.NOT_FOUND)
+      );
+    });
+
+    it('should throw BadRequest for invalid notification type', async () => {
+      service.findById.mockResolvedValue(mockNotificationDb);
+      const invalidUpdateDto = { ...updateDto, type: 'invalid' as any };
+
+      await expect(controller.update(notificationId, invalidUpdateDto)).rejects.toThrow(
+        new HttpException('Invalid notification type. Must be slack, webhook, or discord', HttpStatus.BAD_REQUEST)
+      );
+    });
+
+    it('should validate config when both type and config are provided', async () => {
+      service.findById.mockResolvedValue(mockNotificationDb);
+      const invalidUpdateDto = {
+        type: 'slack' as const,
+        config: { channel: '#general' }, // missing URL
+      };
+
+      await expect(controller.update(notificationId, invalidUpdateDto)).rejects.toThrow(
+        new HttpException('Slack notifications require a webhook URL', HttpStatus.BAD_REQUEST)
+      );
+    });
+
+    it('should re-throw HttpException from service', async () => {
+      const httpError = new HttpException('Service error', HttpStatus.BAD_REQUEST);
+      service.findById.mockResolvedValue(mockNotificationDb);
+      service.update.mockRejectedValue(httpError);
+
+      await expect(controller.update(notificationId, updateDto)).rejects.toThrow(httpError);
+    });
+
+    it('should throw Internal Server Error for other errors', async () => {
+      service.findById.mockResolvedValue(mockNotificationDb);
+      service.update.mockRejectedValue(new Error('Database error'));
+
+      await expect(controller.update(notificationId, updateDto)).rejects.toThrow(
+        new HttpException('Failed to update notification', HttpStatus.INTERNAL_SERVER_ERROR)
+      );
+    });
+  });
+
+  describe('remove', () => {
+    const notificationId = '123';
+
+    it('should delete a notification successfully', async () => {
+      service.delete.mockResolvedValue(undefined);
+
+      const result = await controller.remove(notificationId);
+
+      expect(result).toEqual({
+        success: true,
+        message: 'Notification deleted successfully',
+      });
+      expect(service.delete).toHaveBeenCalledWith(notificationId);
+    });
+
+    it('should throw NotFound when notification does not exist', async () => {
+      service.delete.mockRejectedValue(new Error('Notification not found'));
+
+      await expect(controller.remove(notificationId)).rejects.toThrow(
+        new HttpException('Notification not found', HttpStatus.NOT_FOUND)
+      );
+    });
+
+    it('should throw Internal Server Error for other errors', async () => {
+      service.delete.mockRejectedValue(new Error('Database error'));
+
+      await expect(controller.remove(notificationId)).rejects.toThrow(
+        new HttpException('Failed to delete notification', HttpStatus.INTERNAL_SERVER_ERROR)
+      );
+    });
+  });
+
+  describe('validateNotificationConfig', () => {
+    it('should validate slack config successfully', () => {
+      const config = { url: 'https://hooks.slack.com/test', channel: '#general' };
+      
+      expect(() => {
+        (controller as any).validateNotificationConfig('slack', config);
+      }).not.toThrow();
+    });
+
+    it('should validate webhook config successfully', () => {
+      const config = { url: 'https://webhook.example.com', secret: 'secret' };
+      
+      expect(() => {
+        (controller as any).validateNotificationConfig('webhook', config);
+      }).not.toThrow();
+    });
+
+    it('should validate discord config successfully', () => {
+      const config = { url: 'https://discord.com/api/webhooks/test' };
+      
+      expect(() => {
+        (controller as any).validateNotificationConfig('discord', config);
+      }).not.toThrow();
+    });
+  });
+});
diff --git a/server/src/repo/repo.service.spec.ts b/server/src/repo/repo.service.spec.ts
index 8ac94e4b5..fc11edf18 100644
--- a/server/src/repo/repo.service.spec.ts
+++ b/server/src/repo/repo.service.spec.ts
@@ -135,41 +135,241 @@ describe('RepoService', () => {
     expect(notificationsService.send).toHaveBeenCalled();
     expect(appsService.rebuildApp).toHaveBeenCalled();
   });
-  /*
-  it('should handle github webhook pull_request', async () => {
-    service['githubApi'].getWebhook = jest.fn(() => ({
-      event: 'pull_request',
-      action: 'opened',
-      branch: 'feature',
-      repo: { ssh_url: 'ssh://repo' },
-    }));
-    const headers = {
-      'x-github-event': 'pull_request',
-      'x-github-delivery': 'delivery',
-      'x-hub-signature-256': 'sig',
-    };
-    const body = {};
-    await service.handleWebhook('github', headers, body);
-    expect(appsService.createPRApp).toHaveBeenCalled();
-  });
 
-  it('should handle github webhook pull_request closed', async () => {
-    service['githubApi'].getWebhook = jest.fn(() => ({
-      event: 'pull_request',
-      action: 'closed',
-      branch: 'feature',
-      repo: { ssh_url: 'ssh://repo' },
-    }));
-    const headers = {
-      'x-github-event': 'pull_request',
-      'x-github-delivery': 'delivery',
-      'x-hub-signature-256': 'sig',
-    };
-    const body = {};
-    await service.handleWebhook('github', headers, body);
-    expect(appsService.deletePRApp).toHaveBeenCalled();
+  describe('handleWebhookPullRequest', () => {
+    let originalConsoleLog: any;
+
+    beforeEach(() => {
+      // Mock console.log to avoid output during tests
+      originalConsoleLog = console.log;
+      console.log = jest.fn();
+    });
+
+    afterEach(() => {
+      // Restore console.log
+      console.log = originalConsoleLog;
+      jest.clearAllMocks();
+    });
+
+    it('should create PR app when pull request is opened', async () => {
+      // Mock the webhook response for pull request opened
+      service['githubApi'].getWebhook = jest.fn(() => ({
+        event: 'pull_request',
+        action: 'opened',
+        branch: 'feature-branch',
+        repo: { ssh_url: 'git@github.com:user/repo.git' },
+        repoprovider: 'github',
+        delivery: 'delivery-id',
+        verified: true,
+        body: {},
+      }));
+
+      const headers = {
+        'x-github-event': 'pull_request',
+        'x-github-delivery': 'delivery-id',
+        'x-hub-signature-256': 'signature',
+      };
+      const body = { action: 'opened' };
+
+      await service.handleWebhook('github', headers, body);
+
+      expect(appsService.createPRApp).toHaveBeenCalledWith(
+        'feature-branch',
+        'feature-branch',
+        'git@github.com:user/repo.git',
+        undefined,
+        ['admin']
+      );
+    });
+
+    it('should create PR app when pull request is reopened', async () => {
+      // Mock the webhook response for pull request reopened
+      service['githubApi'].getWebhook = jest.fn(() => ({
+        event: 'pull_request',
+        action: 'reopened',
+        branch: 'feature-branch',
+        repo: { ssh_url: 'git@github.com:user/repo.git' },
+        repoprovider: 'github',
+        delivery: 'delivery-id',
+        verified: true,
+        body: {},
+      }));
+
+      const headers = {
+        'x-github-event': 'pull_request',
+        'x-github-delivery': 'delivery-id',
+        'x-hub-signature-256': 'signature',
+      };
+      const body = { action: 'reopened' };
+
+      await service.handleWebhook('github', headers, body);
+
+      expect(appsService.createPRApp).toHaveBeenCalledWith(
+        'feature-branch',
+        'feature-branch',
+        'git@github.com:user/repo.git',
+        undefined,
+        ['admin']
+      );
+    });
+
+    it('should delete PR app when pull request is closed', async () => {
+      // Mock the webhook response for pull request closed
+      service['githubApi'].getWebhook = jest.fn(() => ({
+        event: 'pull_request',
+        action: 'closed',
+        branch: 'feature-branch',
+        repo: { ssh_url: 'git@github.com:user/repo.git' },
+        repoprovider: 'github',
+        delivery: 'delivery-id',
+        verified: true,
+        body: {},
+      }));
+
+      const headers = {
+        'x-github-event': 'pull_request',
+        'x-github-delivery': 'delivery-id',
+        'x-hub-signature-256': 'signature',
+      };
+      const body = { action: 'closed' };
+
+      await service.handleWebhook('github', headers, body);
+
+      expect(appsService.deletePRApp).toHaveBeenCalledWith(
+        'feature-branch',
+        'feature-branch',
+        'git@github.com:user/repo.git',
+        ['admin']
+      );
+    });
+
+    it('should log unhandled pull request actions', async () => {
+      // Mock the webhook response for an unhandled action (using undefined as it's allowed)
+      service['githubApi'].getWebhook = jest.fn(() => ({
+        event: 'pull_request',
+        action: undefined,
+        branch: 'feature-branch',
+        repo: { ssh_url: 'git@github.com:user/repo.git' },
+        repoprovider: 'github',
+        delivery: 'delivery-id',
+        verified: true,
+        body: {},
+      }));
+
+      const headers = {
+        'x-github-event': 'pull_request',
+        'x-github-delivery': 'delivery-id',
+        'x-hub-signature-256': 'signature',
+      };
+      const body = { action: 'synchronize' };
+
+      await service.handleWebhook('github', headers, body);
+
+      expect(console.log).toHaveBeenCalledWith(
+        'webhook pull request action not handled: undefined'
+      );
+      expect(appsService.createPRApp).not.toHaveBeenCalled();
+      expect(appsService.deletePRApp).not.toHaveBeenCalled();
+    });
+
+    it('should handle pull request webhook from different providers', async () => {
+      // Test with Gitea
+      service['giteaApi'].getWebhook = jest.fn(() => ({
+        event: 'pull_request',
+        action: 'opened',
+        branch: 'pr-branch',
+        repo: { ssh_url: 'git@gitea.example.com:user/repo.git' },
+        repoprovider: 'gitea',
+        delivery: 'gitea-delivery',
+        verified: true,
+        body: {},
+      }));
+
+      const giteaHeaders = {
+        'x-gitea-event': 'pull_request',
+        'x-gitea-delivery': 'gitea-delivery',
+        'x-hub-signature-256': 'gitea-signature',
+      };
+
+      await service.handleWebhook('gitea', giteaHeaders, {});
+
+      expect(appsService.createPRApp).toHaveBeenCalledWith(
+        'pr-branch',
+        'pr-branch',
+        'git@gitea.example.com:user/repo.git',
+        undefined,
+        ['admin']
+      );
+    });
+
+    it('should handle undefined action gracefully', async () => {
+      // Mock webhook with undefined action
+      service['githubApi'].getWebhook = jest.fn(() => ({
+        event: 'pull_request',
+        action: undefined,
+        branch: 'feature-branch',
+        repo: { ssh_url: 'git@github.com:user/repo.git' },
+        repoprovider: 'github',
+        delivery: 'delivery-id',
+        verified: true,
+        body: {},
+      }));
+
+      const headers = {
+        'x-github-event': 'pull_request',
+        'x-github-delivery': 'delivery-id',
+        'x-hub-signature-256': 'signature',
+      };
+
+      await service.handleWebhook('github', headers, {});
+
+      expect(console.log).toHaveBeenCalledWith(
+        'webhook pull request action not handled: undefined'
+      );
+      expect(appsService.createPRApp).not.toHaveBeenCalled();
+      expect(appsService.deletePRApp).not.toHaveBeenCalled();
+    });
+
+    it('should not call appsService methods when webhook is boolean false', async () => {
+      // Mock webhook returning false (invalid webhook)
+      service['githubApi'].getWebhook = jest.fn(() => false);
+
+      const headers = {
+        'x-github-event': 'pull_request',
+        'x-github-delivery': 'delivery-id',
+        'x-hub-signature-256': 'signature',
+      };
+
+      await service.handleWebhook('github', headers, {});
+
+      expect(appsService.createPRApp).not.toHaveBeenCalled();
+      expect(appsService.deletePRApp).not.toHaveBeenCalled();
+    });
+
+    it('should log unhandled pull request actions with direct function call', async () => {
+      // Test the private method directly with an action not in the enum
+      const mockWebhook = {
+        event: 'pull_request',
+        action: 'synchronize' as any, // Force a non-standard action
+        branch: 'feature-branch',
+        repo: { ssh_url: 'git@github.com:user/repo.git' },
+        repoprovider: 'github' as const,
+        delivery: 'delivery-id',
+        verified: true,
+        body: {},
+      };
+
+      // Call the private method directly
+      await (service as any).handleWebhookPullRequest(mockWebhook);
+
+      expect(console.log).toHaveBeenCalledWith(
+        'webhook pull request action not handled: synchronize'
+      );
+      expect(appsService.createPRApp).not.toHaveBeenCalled();
+      expect(appsService.deletePRApp).not.toHaveBeenCalled();
+    });
   });
-*/
+
   it('should handle unknown repo provider', async () => {
     const spy = jest.spyOn(service['logger'], 'debug');
     await service.handleWebhook('unknown', {}, {});
diff --git a/server/src/users/users.service.spec.ts b/server/src/users/users.service.spec.ts
index bdbd3b15d..c17d26ff2 100644
--- a/server/src/users/users.service.spec.ts
+++ b/server/src/users/users.service.spec.ts
@@ -1,5 +1,16 @@
 import { UsersService } from './users.service';
 import { PrismaClient, User as PrismaUser } from '@prisma/client';
+import { HttpException, HttpStatus } from '@nestjs/common';
+import * as bcrypt from 'bcrypt';
+import axios from 'axios';
+
+// Mock bcrypt
+jest.mock('bcrypt');
+const mockedBcrypt = bcrypt as jest.Mocked<typeof bcrypt>;
+
+// Mock axios
+jest.mock('axios');
+const mockedAxios = axios as jest.Mocked<typeof axios>;
 
 describe('UsersService', () => {
   let service: UsersService;
@@ -12,9 +23,18 @@ describe('UsersService', () => {
       delete: jest.Mock;
       count: jest.Mock;
     };
+    role: {
+      findFirst: jest.Mock;
+      findMany: jest.Mock;
+    };
+    userGroup: {
+      findFirst: jest.Mock;
+    };
   };
 
   beforeEach(() => {
+    jest.clearAllMocks();
+    
     prismaMock = {
       user: {
         findUnique: jest.fn(),
@@ -24,8 +44,20 @@ describe('UsersService', () => {
         delete: jest.fn(),
         count: jest.fn(),
       },
+      role: {
+        findFirst: jest.fn(),
+        findMany: jest.fn(),
+      },
+      userGroup: {
+        findFirst: jest.fn(),
+      },
     };
 
+    // Mock bcrypt methods
+    (mockedBcrypt.compare as jest.Mock).mockImplementation(() => Promise.resolve(true));
+    (mockedBcrypt.hash as jest.Mock).mockImplementation(() => Promise.resolve('hashedPassword'));
+    (mockedBcrypt.hashSync as jest.Mock).mockImplementation(() => 'hashedPassword');
+
     service = new UsersService();
     // @ts-ignore
     service['prisma'] = prismaMock;
@@ -178,4 +210,438 @@ describe('UsersService', () => {
     prismaMock.user.findUnique.mockResolvedValueOnce(null);
     expect(await service.exists('notfound')).toBe(false);
   });
+
+  describe('findOneFull', () => {
+    it('should find a user with full details including relations', async () => {
+      const mockUser = {
+        id: '1',
+        username: 'user1',
+        email: 'user1@example.com',
+        tokens: [{ id: 'token1', createdAt: new Date(), expiresAt: new Date() }],
+        role: { id: 'role1', name: 'admin', description: 'Administrator' },
+        userGroups: [{ id: 'group1', name: 'admins', description: 'Admin group' }],
+      };
+      prismaMock.user.findUnique.mockResolvedValueOnce(mockUser);
+
+      const result = await service.findOneFull('user1');
+
+      expect(result).toBe(mockUser);
+      expect(prismaMock.user.findUnique).toHaveBeenCalledWith({
+        where: { username: 'user1' },
+        include: {
+          tokens: {
+            select: {
+              id: true,
+              createdAt: true,
+              expiresAt: true,
+            },
+          },
+          role: {
+            select: {
+              id: true,
+              name: true,
+              description: true,
+            },
+          },
+          userGroups: {
+            select: {
+              id: true,
+              name: true,
+              description: true,
+            },
+          },
+        },
+      });
+    });
+
+    it('should return null if user not found', async () => {
+      prismaMock.user.findUnique.mockResolvedValueOnce(null);
+
+      const result = await service.findOneFull('nonexistent');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('findOneOrCreate', () => {
+    it('should return existing user if found', async () => {
+      const existingUser = {
+        id: '1',
+        username: 'existinguser',
+        email: 'existing@example.com',
+      };
+      prismaMock.user.findUnique.mockResolvedValueOnce(existingUser);
+
+      const result = await service.findOneOrCreate(
+        'existinguser',
+        'existing@example.com',
+        'oauth2',
+        'https://example.com/avatar.jpg'
+      );
+
+      expect(result).toBe(existingUser);
+    });
+
+    it('should create new user if not found', async () => {
+      const mockRole = { id: 'role1', name: 'guest' };
+      const mockUserGroup = { id: 'group1', name: 'everyone' };
+      const newUser = { id: '2', username: 'newuser' };
+
+      prismaMock.user.findUnique.mockResolvedValueOnce(null); // User not found
+      prismaMock.role.findFirst.mockResolvedValueOnce(mockRole);
+      prismaMock.userGroup.findFirst.mockResolvedValueOnce(mockUserGroup);
+      prismaMock.user.create.mockResolvedValueOnce(newUser);
+
+      // Mock axios for image processing
+      mockedAxios.get.mockResolvedValueOnce({
+        status: 200,
+        data: Buffer.from('fake-image-data'),
+        headers: { 'content-type': 'image/jpeg' },
+      });
+
+      const result = await service.findOneOrCreate(
+        'newuser',
+        'new@example.com',
+        'oauth2',
+        'https://example.com/avatar.jpg'
+      );
+
+      expect(result).toBe(newUser);
+      expect(prismaMock.user.create).toHaveBeenCalled();
+    });
+
+    it('should throw error if default role not found', async () => {
+      prismaMock.user.findUnique.mockResolvedValueOnce(null);
+      prismaMock.role.findFirst.mockResolvedValueOnce(null);
+
+      await expect(
+        service.findOneOrCreate('newuser', 'new@example.com', 'oauth2', '')
+      ).rejects.toThrow('Default role not found');
+    });
+
+    it('should throw error if default user group not found', async () => {
+      prismaMock.user.findUnique.mockResolvedValueOnce(null);
+      prismaMock.role.findFirst.mockResolvedValueOnce({ id: 'role1', name: 'guest' });
+      prismaMock.userGroup.findFirst.mockResolvedValueOnce(null);
+
+      await expect(
+        service.findOneOrCreate('newuser', 'new@example.com', 'oauth2', '')
+      ).rejects.toThrow('Default user group not found');
+    });
+  });
+
+  describe('findByUsername', () => {
+    it('should find user by username', async () => {
+      const mockUser = { id: '1', username: 'testuser' };
+      prismaMock.user.findUnique.mockResolvedValueOnce(mockUser);
+
+      const result = await service.findByUsername('testuser');
+
+      expect(result).toBe(mockUser);
+      expect(prismaMock.user.findUnique).toHaveBeenCalledWith({
+        where: { username: 'testuser' },
+      });
+    });
+  });
+
+  describe('updateMyPassword', () => {
+    it('should update password when current password is correct', async () => {
+      const mockUser = { id: '1', password: 'hashedCurrentPassword' };
+      const updatedUser = { id: '1', password: 'hashedNewPassword' };
+
+      prismaMock.user.findUnique.mockResolvedValueOnce(mockUser);
+      (mockedBcrypt.compare as jest.Mock).mockResolvedValueOnce(true);
+      (mockedBcrypt.hash as jest.Mock).mockResolvedValueOnce('hashedNewPassword');
+      prismaMock.user.update.mockResolvedValueOnce(updatedUser);
+
+      const result = await service.updateMyPassword('1', 'currentPass', 'newPassword123');
+
+      expect(result).toBe(updatedUser);
+      expect(mockedBcrypt.compare).toHaveBeenCalledWith('currentPass', 'hashedCurrentPassword');
+      expect(mockedBcrypt.hash).toHaveBeenCalledWith('newPassword123', 10);
+    });
+
+    it('should return undefined for invalid input parameters', async () => {
+      const result1 = await service.updateMyPassword('1', '', 'newPassword123');
+      const result2 = await service.updateMyPassword('1', 'currentPass', '');
+      const result3 = await service.updateMyPassword('1', 'currentPass', 'short');
+
+      expect(result1).toBeUndefined();
+      expect(result2).toBeUndefined();
+      expect(result3).toBeUndefined();
+    });
+
+    it('should return undefined when user not found', async () => {
+      prismaMock.user.findUnique.mockResolvedValueOnce(null);
+
+      const result = await service.updateMyPassword('1', 'currentPass', 'newPassword123');
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should throw HttpException when current password is incorrect', async () => {
+      const mockUser = { id: '1', password: 'hashedCurrentPassword' };
+      prismaMock.user.findUnique.mockResolvedValueOnce(mockUser);
+      (mockedBcrypt.compare as jest.Mock).mockResolvedValueOnce(false);
+
+      await expect(
+        service.updateMyPassword('1', 'wrongPassword', 'newPassword123')
+      ).rejects.toThrow(HttpException);
+    });
+
+    it('should propagate database errors', async () => {
+      const mockUser = { id: '1', password: 'hashedCurrentPassword' };
+      prismaMock.user.findUnique.mockResolvedValueOnce(mockUser);
+      (mockedBcrypt.compare as jest.Mock).mockResolvedValueOnce(true);
+      (mockedBcrypt.hash as jest.Mock).mockResolvedValueOnce('hashedNewPassword');
+      prismaMock.user.update.mockRejectedValueOnce(new Error('Database error'));
+
+      await expect(
+        service.updateMyPassword('1', 'currentPass', 'newPassword123')
+      ).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('listUsersByGroup', () => {
+    it('should return users belonging to a specific group', async () => {
+      const mockUsers = [
+        { id: '1', username: 'user1' },
+        { id: '2', username: 'user2' },
+      ];
+      prismaMock.user.findMany.mockResolvedValueOnce(mockUsers);
+
+      const result = await service.listUsersByGroup('group1');
+
+      expect(result).toBe(mockUsers);
+      expect(prismaMock.user.findMany).toHaveBeenCalledWith({
+        where: {
+          userGroups: {
+            some: {
+              id: 'group1',
+            },
+          },
+        },
+      });
+    });
+  });
+
+  describe('findAllRoles', () => {
+    it('should return all roles', async () => {
+      const mockRoles = [
+        { id: '1', name: 'admin', description: 'Administrator' },
+        { id: '2', name: 'user', description: 'Regular user' },
+      ];
+      prismaMock.role.findMany.mockResolvedValueOnce(mockRoles);
+
+      const result = await service.findAllRoles();
+
+      expect(result).toBe(mockRoles);
+      expect(prismaMock.role.findMany).toHaveBeenCalledWith({
+        select: {
+          id: true,
+          name: true,
+          description: true,
+          createdAt: true,
+          updatedAt: true,
+        },
+      });
+    });
+  });
+
+  describe('updateAvatar', () => {
+    it('should update user avatar successfully', async () => {
+      const mockFile = {
+        buffer: Buffer.from('fake-image-data'),
+        mimetype: 'image/jpeg',
+      };
+      const updatedUser = { id: '1', image: 'data:image/jpeg;base64,ZmFrZS1pbWFnZS1kYXRh' };
+
+      prismaMock.user.update.mockResolvedValueOnce(updatedUser);
+
+      const result = await service.updateAvatar('1', mockFile);
+
+      expect(result).toBe(updatedUser);
+      expect(prismaMock.user.update).toHaveBeenCalledWith({
+        where: { id: '1' },
+        data: { image: 'data:image/jpeg;base64,ZmFrZS1pbWFnZS1kYXRh' },
+      });
+    });
+
+    it('should return undefined when no file buffer provided', async () => {
+      const result1 = await service.updateAvatar('1', null);
+      const result2 = await service.updateAvatar('1', { buffer: null });
+
+      expect(result1).toBeUndefined();
+      expect(result2).toBeUndefined();
+    });
+
+    it('should return undefined when update fails', async () => {
+      const mockFile = {
+        buffer: Buffer.from('fake-image-data'),
+        mimetype: 'image/jpeg',
+      };
+      prismaMock.user.update.mockRejectedValueOnce(new Error('User not found'));
+
+      const result = await service.updateAvatar('1', mockFile);
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getAvatar', () => {
+    it('should return user avatar', async () => {
+      const mockUser = { image: 'data:image/jpeg;base64,ZmFrZS1pbWFnZS1kYXRh' };
+      prismaMock.user.findUnique.mockResolvedValueOnce(mockUser);
+
+      const result = await service.getAvatar('1');
+
+      expect(result).toBe(mockUser.image);
+      expect(prismaMock.user.findUnique).toHaveBeenCalledWith({
+        where: { id: '1' },
+        select: { image: true },
+      });
+    });
+
+    it('should return null when user not found', async () => {
+      prismaMock.user.findUnique.mockResolvedValueOnce(null);
+
+      const result = await service.getAvatar('1');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('generateUserDataFromImageUrl', () => {
+    it('should generate base64 image data from URL', async () => {
+      const imageBuffer = Buffer.from('fake-image-data');
+      mockedAxios.get.mockResolvedValueOnce({
+        status: 200,
+        data: imageBuffer,
+        headers: { 'content-type': 'image/jpeg' },
+      });
+
+      const result = await (service as any).generateUserDataFromImageUrl('https://example.com/image.jpg');
+
+      expect(result).toBe(`data:image/jpeg;base64,${imageBuffer.toString('base64')}`);
+      expect(mockedAxios.get).toHaveBeenCalledWith('https://example.com/image.jpg', {
+        responseType: 'arraybuffer',
+      });
+    });
+
+    it('should throw error when image fetch fails', async () => {
+      mockedAxios.get.mockResolvedValueOnce({
+        status: 404,
+        data: null,
+        headers: {},
+      });
+
+      await expect(
+        (service as any).generateUserDataFromImageUrl('https://example.com/notfound.jpg')
+      ).rejects.toThrow('Failed to fetch image from URL');
+    });
+
+    it('should throw error for invalid MIME type', async () => {
+      mockedAxios.get.mockResolvedValueOnce({
+        status: 200,
+        data: Buffer.from('not-an-image'),
+        headers: { 'content-type': 'text/plain' },
+      });
+
+      await expect(
+        (service as any).generateUserDataFromImageUrl('https://example.com/text.txt')
+      ).rejects.toThrow('Invalid image MIME type');
+    });
+
+    it('should default to image/jpeg when no content-type header', async () => {
+      const imageBuffer = Buffer.from('fake-image-data');
+      mockedAxios.get.mockResolvedValueOnce({
+        status: 200,
+        data: imageBuffer,
+        headers: {},
+      });
+
+      const result = await (service as any).generateUserDataFromImageUrl('https://example.com/image');
+
+      expect(result).toBe(`data:image/jpeg;base64,${imageBuffer.toString('base64')}`);
+    });
+  });
+
+  describe('create with error handling', () => {
+    it('should throw error when no password provided', async () => {
+      const userWithoutPassword = { username: 'testuser', email: 'test@example.com' };
+
+      await expect(service.create(userWithoutPassword)).rejects.toThrow(
+        'Password is required for user creation.'
+      );
+    });
+
+    it('should throw error when empty password provided', async () => {
+      const userWithEmptyPassword = { username: 'testuser', password: '', email: 'test@example.com' };
+
+      await expect(service.create(userWithEmptyPassword)).rejects.toThrow(
+        'Password is required for user creation.'
+      );
+    });
+  });
+
+  describe('updatePassword edge cases', () => {
+    it('should return undefined for invalid password parameters', async () => {
+      const result1 = await service.updatePassword('1', '');
+      const result2 = await service.updatePassword('1', null as any);
+      const result3 = await service.updatePassword('1', 123 as any);
+
+      expect(result1).toBeUndefined();
+      expect(result2).toBeUndefined();
+      expect(result3).toBeUndefined();
+    });
+  });
+
+  describe('update edge cases', () => {
+    it('should return undefined when no valid fields provided', async () => {
+      const result = await service.update('1', {
+        id: 'ignored',
+        createdAt: 'ignored',
+        updatedAt: 'ignored',
+        password: 'ignored',
+      });
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should handle role and userGroups relations correctly', async () => {
+      const updatedUser = { id: '1', username: 'updated' };
+      prismaMock.user.update.mockResolvedValueOnce(updatedUser);
+
+      const updateData = {
+        username: 'newusername',
+        role: 'role123',
+        userGroups: [{ id: 'group1' }, 'group2'],
+      };
+
+      const result = await service.update('1', updateData);
+
+      expect(result).toBe(updatedUser);
+      expect(prismaMock.user.update).toHaveBeenCalledWith({
+        omit: { password: true },
+        where: { id: '1' },
+        data: {
+          username: 'newusername',
+          role: { connect: { id: 'role123' } },
+          userGroups: {
+            set: [],
+            connect: [{ id: 'group1' }, { id: 'group2' }],
+          },
+        },
+      });
+    });
+  });
+
+  describe('delete error handling', () => {
+    it('should handle deletion errors gracefully', async () => {
+      prismaMock.user.delete.mockRejectedValueOnce(new Error('User not found'));
+
+      // Should not throw, but handle gracefully
+      await expect(service.delete('nonexistent')).resolves.toBeUndefined();
+    });
+  });
 });