code coverage

.gitignore

@@ -9,6 +9,7 @@ lerna-debug.log*
 
 node_modules
 dist
+coverage
 dist-ssr
 *.local
 

lib/__tests__/tmss/BaseTmssTemplate.test.ts

+import { describe, it, expect } from 'vitest';
+import BaseTMSSTemplate from '../../models/tmss/BaseTmssTemplate';  
+
+const validTemplate: BaseTMSSTemplate = {
+  id: 'template1',
+  url: 'https://tmss.lofar.eu/lla',
+  description: 'A sample template',
+  name: 'Template One',
+  version: '1.0.0',
+};
+
+
+describe('BaseTMSSTemplate', () => {
+  it('should conform to BaseTMSSTemplate interface', () => {
+    expect(validTemplate).toEqual({
+      id: 'template1',
+      url: 'https://tmss.lofar.eu/lla',
+      description: 'A sample template',
+      name: 'Template One',
+      version: '1.0.0',
+    });
+  });
+
+
+});

lib/__tests__/tmss/CommonSchemaTemplate.test.ts

+import CommonSchemaTemplate from '../../models/tmss/CommonSchemaTemplate';  
+import { describe, it, expect } from 'vitest';
+import BaseTMSSTemplate from '../../models/tmss/BaseTmssTemplate';  
+
+const validTemplate: CommonSchemaTemplate = {
+  id: 'template1',
+  url: 'https://tmss.lofar.eu/lla',
+  description: 'A sample template',
+  name: 'Template One',
+  version: '1.0.0',
+};
+
+
+describe('BaseTMSSTemplate', () => {
+  it('should conform to BaseTMSSTemplate interface', () => {
+    const isBaseTMSSTemplate: BaseTMSSTemplate = validTemplate;
+    expect(isBaseTMSSTemplate).toEqual({
+      id: 'template1',
+      url: 'https://tmss.lofar.eu/lla',
+      description: 'A sample template',
+      name: 'Template One',
+      version: '1.0.0',
+    });
+  });
+
+
+});

lib/__tests__/tmss/Cycle.test.ts

+import { describe, it, expect } from 'vitest';
+import Cycle from "../../models/tmss/Cycle";
+
+describe('Cycle Interface', () => {
+
+    const cycle: Cycle = {
+        name: 'Cycle 1',
+        url: 'http://example.com',
+        created_at: '2023-01-01T00:00:00Z',
+        updated_at: '2023-01-02T00:00:00Z',
+        description: 'This is a test cycle.',
+        duration: 30,
+        project: ['Project 1', 'Project 2'],
+        project_ids: ['1', '2'],
+        start: '2023-01-01T00:00:00Z',
+        stop: '2023-01-31T23:59:59Z',
+        tags: ['tag1', 'tag2'],
+        quota: ['Quota 1', 'Quota 2'],
+        qupta_ids: [1, 2]
+      };
+      
+  it('should have correct structure', () => {
+    expect(cycle).toHaveProperty('name');
+    expect(cycle).toHaveProperty('url');
+    expect(cycle).toHaveProperty('created_at');
+    expect(cycle).toHaveProperty('updated_at');
+    expect(cycle).toHaveProperty('description');
+    expect(cycle).toHaveProperty('duration');
+    expect(cycle).toHaveProperty('project');
+    expect(cycle).toHaveProperty('project_ids');
+    expect(cycle).toHaveProperty('start');
+    expect(cycle).toHaveProperty('stop');
+    expect(cycle).toHaveProperty('tags');
+    expect(cycle).toHaveProperty('quota');
+    expect(cycle).toHaveProperty('qupta_ids');
+  });
+
+  it('should have correct types', () => {
+    expect(typeof cycle.name).toBe('string');
+    expect(typeof cycle.url).toBe('string');
+    expect(typeof cycle.created_at).toBe('string');
+    expect(typeof cycle.updated_at).toBe('string');
+    expect(typeof cycle.description).toBe('string');
+    expect(typeof cycle.duration).toBe('number');
+    expect(Array.isArray(cycle.project)).toBe(true);
+    expect(Array.isArray(cycle.project_ids)).toBe(true);
+    expect(typeof cycle.start).toBe('string');
+    expect(typeof cycle.stop).toBe('string');
+    expect(Array.isArray(cycle.tags)).toBe(true);
+    expect(Array.isArray(cycle.quota)).toBe(true);
+    expect(Array.isArray(cycle.qupta_ids)).toBe(true);
+  });
+});

lib/__tests__/tmss/PriorityQueue.test.ts

+import { describe, it, expect } from 'vitest';
+import PriorityQueue from '../../models/tmss/PriorityQueue'; // Adjust the import path as necessary
+
+describe('PriorityQueue', () => {
+  it('should have a static property PriorityQueueA with value "A"', () => {
+    expect(PriorityQueue.PriorityQueueA).toBe("A");
+  });
+
+  it('should have a static property PriorityQueueB with value "B"', () => {
+    expect(PriorityQueue.PriorityQueueB).toBe("B");
+  });
+
+  it('should have a static property AllQueues containing ["A", "B"]', () => {
+    expect(PriorityQueue.AllQueues).toEqual(["A", "B"]);
+  });
+});

lib/__tests__/tmss/ScheduleSpecification.test.ts

+import { describe, it, expect } from 'vitest';
+import ScheduleSpecification from '../../models/tmss/ScheduleSpecification';
+
+describe('ScheduleSpecification Interface', () => {
+
+
+  it('should create a valid ScheduleSpecification object with optional scheduling_constraints_template_id', () => {
+    const schedule: ScheduleSpecification = {
+      name: 'Test Schedule',
+      description: 'A description for the test schedule',
+      scheduling_constraints_template_id: '12345'
+    };
+
+    expect(schedule.name).toBe('Test Schedule');
+    expect(schedule.description).toBe('A description for the test schedule');
+    expect(schedule.scheduling_constraints_template_id).toBe('12345');
+  });
+
+  it('should allow scheduling_constraints_template_id to be undefined', () => {
+    const schedule: ScheduleSpecification = {
+      name: 'Test Schedule',
+      description: 'A description for the test schedule',
+      scheduling_constraints_template_id: undefined
+    };
+    expect(schedule.scheduling_constraints_template_id).toBeUndefined();
+  });
+
+});

lib/__tests__/tmss/SchedulintContraintsTemplate.test.ts

+import { describe, it, expect } from 'vitest';
+import { SchedulingConstraintsTemplate, RefResolvedSchema, SchedulingConstraintsTemplateProperties, SkyProperties, SkyNestedProperties, TransitOffsetProperties, TransitOffsetNestedProperties, MinDistanceProperties, MinDistanceNestedProperties, DefaultProperty, PropertyOrder } from '../../models/tmss/SchedulingConstraintsTemplate'
+
+// Create a mock object that adheres to the SchedulingConstraintsTemplate interface
+const mockSchedulingConstraintsTemplate: SchedulingConstraintsTemplate = {
+  id: 'template1',
+  url: 'https://tmss.lofar.eu/template1',
+  description: 'A sample scheduling constraints template',
+  name: 'Scheduling Constraints Template',
+  version: '1.0.0',
+  ref_resolved_schema: {
+    properties: {
+      sky: {
+        properties: {
+          transit_offset: {
+            properties: {
+              from: { default: '00:00' },
+              to: { default: '12:00' }
+            }
+          },
+          min_distance: {
+            properties: {
+              sun: { propertyOrder: 1 },
+              moon: { propertyOrder: 2 },
+              jupiter: { propertyOrder: 3 }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+describe('SchedulingConstraintsTemplate', () => {
+  it('should have all required properties', () => {
+    expect(mockSchedulingConstraintsTemplate).toHaveProperty('id', 'template1');
+    expect(mockSchedulingConstraintsTemplate).toHaveProperty('url', 'https://tmss.lofar.eu/template1');
+    expect(mockSchedulingConstraintsTemplate).toHaveProperty('description', 'A sample scheduling constraints template');
+    expect(mockSchedulingConstraintsTemplate).toHaveProperty('name', 'Scheduling Constraints Template');
+    expect(mockSchedulingConstraintsTemplate).toHaveProperty('version', '1.0.0');
+
+    const refResolvedSchema = mockSchedulingConstraintsTemplate.ref_resolved_schema;
+    expect(refResolvedSchema).toHaveProperty('properties');
+
+    const schedulingProperties = refResolvedSchema.properties;
+    expect(schedulingProperties).toHaveProperty('sky');
+
+    const skyProperties = schedulingProperties.sky.properties;
+    expect(skyProperties).toHaveProperty('transit_offset');
+    expect(skyProperties).toHaveProperty('min_distance');
+
+    const transitOffset = skyProperties.transit_offset.properties;
+    expect(transitOffset).toHaveProperty('from');
+    expect(transitOffset).toHaveProperty('to');
+    expect(transitOffset.from).toHaveProperty('default', '00:00');
+    expect(transitOffset.to).toHaveProperty('default', '12:00');
+
+    const minDistance = skyProperties.min_distance.properties;
+    expect(minDistance).toHaveProperty('sun');
+    expect(minDistance).toHaveProperty('moon');
+    expect(minDistance).toHaveProperty('jupiter');
+    expect(minDistance.sun).toHaveProperty('propertyOrder', 1);
+    expect(minDistance.moon).toHaveProperty('propertyOrder', 2);
+    expect(minDistance.jupiter).toHaveProperty('propertyOrder', 3);
+  });
+});

package.json

 {
   "name": "@astron-sd/telescope-specification-models",
   "private": false,
-  "version": "0.0.45",
+  "version": "0.0.46",
   "type": "module",
   "main": "./dist/telescope-specification-models.cjs",
   "module": "./dist/telescope-specification-models.es.js",
@@ -15,7 +15,8 @@
     "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0",
     "preview": "vite preview",
     "prepublishOnly": "npm run build",
-    "test": "vitest"
+    "test": "vitest",
+    "coverage": "vitest run --coverage --reporter=junit --outputFile=./coverage/junit.xml "
   },
   "peerDependencies": {
   
@@ -26,7 +27,9 @@
     "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-react-refresh": "^0.4.6",
     "vite": "^5.2.11",
-    "vite-plugin-dts": "^3.9.1"
+    "vite-plugin-dts": "^3.9.1",
+    "vitest": "^1.6.0",
+    "@vitest/coverage-v8": "^1.6.0"
 
   },
   "dependencies": {

vite.config.js

@@ -3,15 +3,22 @@ import { resolve } from 'path'
 import dts from 'vite-plugin-dts'
 import * as packageJson from "./package.json";
 
-
-// https://vitejs.dev/config/
 export default defineConfig({
   resolve: {
     alias: {
     }
   },
+  test: {
+    globals: true,
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "lcov", "html"],
+      include: ["lib/models/**/*.ts"], // Ensure all relevant files are included
+      all:true,
+    },
+  },
   plugins: [dts({
-    insertTypesEntry: true,  // Optional: Inserts the type entry in the package.json
+    insertTypesEntry: true,  
       include: ['lib'] ,