Live Observing Session
You are controlling the {{ telescope }} telescope in {{ site }}
Time Remaining in session: {{ formatCountdown(timeRemaining) }}
+
diff --git a/src/components/Views/SchedulingView.vue b/src/components/Views/SchedulingView.vue
index ac6c90a..38b35dd 100644
--- a/src/components/Views/SchedulingView.vue
+++ b/src/components/Views/SchedulingView.vue
@@ -1,43 +1,169 @@
- Session has ended
-
-
-
-
-
-
-
+
+
+
+
diff --git a/src/stores/obsPortalData.js b/src/stores/obsPortalData.js
new file mode 100644
index 0000000..4c01e4a
--- /dev/null
+++ b/src/stores/obsPortalData.js
@@ -0,0 +1,60 @@
+import { defineStore } from 'pinia'
+import { fetchApiCall } from '../utils/api'
+import { useUserDataStore } from './userData'
+import { useConfigurationStore } from './configuration'
+
+const fifteenDaysAgo = new Date(new Date().getTime() - 15 * 24 * 60 * 60 * 1000).toISOString().split('T')[0]
+
+export const useObsPortalDataStore = defineStore('obsPortalData', {
+ state () {
+ return {
+ completedObservations: {},
+ upcomingRealTimeSessions: {},
+ pendingRequestGroups: []
+ }
+ },
+ persist: true,
+ actions: {
+ sortResponseData (response) {
+ // we only want to display observations that are either COMPLETED or REAL_TIME and have ended and since each session lasts 15 minutes, we only want to display sessions that have ended in the last 16 minutes
+ const sixteenMinutes = 16 * 60 * 1000
+ const sessionCutoff = new Date(new Date().getTime() - sixteenMinutes).toISOString()
+ for (const result of response.results) {
+ const sessionEnd = new Date(result.end).toISOString()
+ if ((result.state === 'COMPLETED') || (result.observation_type === 'REAL_TIME' && sessionEnd < sessionCutoff)) {
+ if (!this.completedObservations[result.id]) {
+ this.completedObservations[result.id] = result
+ }
+ } else if (result.observation_type === 'REAL_TIME' && sessionEnd > sessionCutoff) {
+ if (!this.upcomingRealTimeSessions[result.id]) {
+ this.upcomingRealTimeSessions[result.id] = result
+ }
+ }
+ }
+ },
+ async fetchCompleteObservationsAndUpcomingRTSessions () {
+ const configurationStore = useConfigurationStore()
+ const userDataStore = useUserDataStore()
+ const username = userDataStore.username
+ await fetchApiCall({
+ url: configurationStore.observationPortalUrl + `observations/?user=${username}&state=PENDING&state=COMPLETED&limit=1000&ordering=start&created_after=${fifteenDaysAgo}`,
+ method: 'GET',
+ successCallback: (response) => {
+ this.sortResponseData(response)
+ }
+ })
+ },
+ fetchPendingRequestGroups () {
+ const configurationStore = useConfigurationStore()
+ const userDataStore = useUserDataStore()
+ const username = userDataStore.username
+ fetchApiCall({
+ url: configurationStore.observationPortalUrl + `requestgroups/?observation_type=NORMAL&state=PENDING&user=${username}created_after=${fifteenDaysAgo}`,
+ method: 'GET',
+ successCallback: (response) => {
+ this.pendingRequestGroups = response.results
+ }
+ })
+ }
+ }
+})
diff --git a/src/stores/sessions.js b/src/stores/realTimeSessions.js
similarity index 77%
rename from src/stores/sessions.js
rename to src/stores/realTimeSessions.js
index d3f8470..d399fc6 100644
--- a/src/stores/sessions.js
+++ b/src/stores/realTimeSessions.js
@@ -3,11 +3,11 @@ import { fetchApiCall } from '../utils/api'
import { calculateSessionCountdown } from '../utils/formatTime'
import { toRaw } from 'vue'
import { useConfigurationStore } from './configuration'
+import { useObsPortalDataStore } from './obsPortalData'
-export const useSessionsStore = defineStore('sessions', {
+export const useRealTimeSessionsStore = defineStore('realTimeSessions', {
state () {
return {
- sessions: [],
currentSessionId: null,
currentStatus: '',
fetchInterval: null,
@@ -18,13 +18,12 @@ export const useSessionsStore = defineStore('sessions', {
persist: true,
getters: {
currentSession (state) {
- const currentSession = state.sessions.results.find(session => session.id === state.currentSessionId)
+ const obsPortalDataStore = useObsPortalDataStore()
+ const upcomingRealTimeSessions = obsPortalDataStore.upcomingRealTimeSessions
+ const currentSession = upcomingRealTimeSessions[state.currentSessionId]
// for some reason, vue3 returns a *proxy* object that we can't send over HTTP, so convert it to JSON first.
return toRaw(currentSession)
},
- getAllSessions (state) {
- return state.sessions
- },
getTokenForCurrentSession (state) {
return state.sessionTokens[state.currentSessionId] || ''
},
@@ -38,23 +37,6 @@ export const useSessionsStore = defineStore('sessions', {
this.isCapturingImagesMap[this.currentSessionId] = false
}
},
- async fetchSessions () {
- const configurationStore = useConfigurationStore()
- await fetchApiCall({
- url: configurationStore.observationPortalUrl + 'observations/?observation_type=REAL_TIME&limit=1000&ordering=start',
- method: 'GET',
- successCallback: (response) => {
- this.sessions = response
- }
- })
- if (this.sessions.results.length > 0) {
- for (const session of this.sessions.results) {
- if (session.date) {
- session.date = new Date(session.date)
- }
- }
- }
- },
async fetchSessionToken () {
const configurationStore = useConfigurationStore()
const requestBody = { ...this.currentSession }
@@ -95,7 +77,6 @@ export const useSessionsStore = defineStore('sessions', {
} else if (this.currentStatus === 'ACTIVE') {
nextInterval = 1000
}
-
this.fetchInterval = setTimeout(poll, nextInterval)
}
diff --git a/src/tests/integration/components/beginnerScheduling.test.js b/src/tests/integration/components/beginnerScheduling.test.js
new file mode 100644
index 0000000..07295c6
--- /dev/null
+++ b/src/tests/integration/components/beginnerScheduling.test.js
@@ -0,0 +1,72 @@
+import { mount } from '@vue/test-utils'
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+import BeginnerScheduling from '../../../components/Scheduling/BeginnerScheduling.vue'
+import { fetchApiCall } from '../../../utils/api.js'
+import { createTestStores } from '../../../utils/testUtils'
+import flushPromises from 'flush-promises'
+
+vi.mock('@/utils/api.js', () => ({
+ fetchApiCall: vi.fn()
+}))
+
+describe('BeginnerScheduling.vue', () => {
+ let wrapper
+
+ beforeEach(() => {
+ fetchApiCall.mockClear()
+ const { pinia } = createTestStores()
+
+ wrapper = mount(BeginnerScheduling, {
+ global: {
+ plugins: [pinia]
+ }
+ })
+ })
+
+ it('calls fetchApiCall when date range is updated', async () => {
+ const mockResponse = {
+ targets: [
+ {
+ name: 'Target 1',
+ ra: 187.25,
+ dec: -11.56,
+ avmdesc: 'Galaxy',
+ desc: 'A cool target',
+ filters: [{ name: 'Filter 1', exposure: 300, count: 5 }]
+ }
+ ]
+ }
+
+ fetchApiCall.mockImplementationOnce(({ successCallback }) => {
+ successCallback(mockResponse)
+ })
+
+ // Simulate selecting a date range (which triggers fetchTargets)
+ const startDate = new Date()
+ const endDate = new Date()
+ // Adds 15 days to the start date
+ endDate.setDate(startDate.getDate() + 15)
+
+ const newDateRange = [startDate, endDate]
+
+ await wrapper.vm.handleDateRangeUpdate(newDateRange)
+
+ expect(fetchApiCall).toHaveBeenCalledTimes(1)
+ expect(fetchApiCall).toHaveBeenCalledWith({
+ url: `https://whatsup.lco.global/range/?start=${startDate.toISOString().split('.')[0]}&end=${endDate.toISOString().split('.')[0]}&aperture=0m4&mode=full`,
+ method: 'GET',
+ successCallback: expect.any(Function),
+ failCallback: expect.any(Function)
+ })
+
+ await flushPromises()
+
+ expect(wrapper.vm.selectedTargets.length).toBe(1)
+ expect(wrapper.vm.selectedTargets[0].name).toBe('Target 1')
+ expect(wrapper.vm.selectedTargets[0].ra).toBe(187.25)
+ expect(wrapper.vm.selectedTargets[0].dec).toBe(-11.56)
+ expect(wrapper.vm.selectedTargets[0].filters[0].name).toBe('Filter 1')
+ expect(wrapper.vm.selectedTargets[0].filters[0].exposure).toBe(300)
+ expect(wrapper.vm.selectedTargets[0].filters[0].count).toBe(5)
+ })
+})
diff --git a/src/tests/integration/components/myGallery.test.js b/src/tests/integration/components/myGallery.test.js
index c44bb49..7d63fe3 100644
--- a/src/tests/integration/components/myGallery.test.js
+++ b/src/tests/integration/components/myGallery.test.js
@@ -15,16 +15,13 @@ vi.mock('../../../utils/api.js', () => ({
// Avoids cross-test pollution and ensures a clean slate for each test
function createComponent () {
// Initialize the stores using the shared utility
- const { pinia, sessionsStore } = createTestStores()
+ const { pinia, obsPortalDataStore } = createTestStores()
// Set up initial state for the sessions store
- sessionsStore.sessions = {
- results: [
- { id: 'session1', start: '2024-08-01T12:00:00Z' },
- { id: 'session2', start: '2024-08-01T12:30:00Z' }
- ]
+ obsPortalDataStore.completedObservations = {
+ 'session1': { id: 'session1', start: '2024-08-01T12:00:00Z' },
+ 'session2': { id: 'session2', start: '2024-08-01T12:30:00Z' }
}
-
// Mount the component with the pinia stores provided
return mount(MyGallery, {
global: {
@@ -46,7 +43,6 @@ describe('MyGallery.vue', () => {
it('fetches thumbnails for each session on mount', async () => {
fetchApiCall.mockImplementation(({ url, successCallback }) => {
- console.log('THIS IS URL:', url)
if (url.includes('session1')) {
successCallback({
results: [{ url: 'http://mock-image.com/image1.jpg' }]
diff --git a/src/tests/integration/components/schedulingSettings.test.js b/src/tests/integration/components/schedulingSettings.test.js
new file mode 100644
index 0000000..4f7f835
--- /dev/null
+++ b/src/tests/integration/components/schedulingSettings.test.js
@@ -0,0 +1,147 @@
+import { mount } from '@vue/test-utils'
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+import SchedulingSettings from '../../../components/Scheduling/SchedulingSettings.vue'
+import { fetchApiCall } from '../../../utils/api.js'
+import { createTestStores } from '../../../utils/testUtils'
+import flushPromises from 'flush-promises'
+
+vi.mock('@/utils/api.js', () => ({
+ fetchApiCall: vi.fn()
+}))
+
+describe('SchedulingSettings.vue', () => {
+ let wrapper
+
+ beforeEach(() => {
+ fetchApiCall.mockClear()
+ const { pinia } = createTestStores()
+
+ fetchApiCall.mockImplementationOnce(({ successCallback }) => {
+ if (successCallback) {
+ successCallback({
+ '0M4-SCICAM-QHY600': {
+ 'class': '0m4',
+ 'optical_elements': {
+ 'filters': [
+ { name: 'Filter A', code: 'FA', schedulable: true },
+ { name: 'Filter B', code: 'FB', schedulable: false }
+ ]
+ }
+ },
+ '0M4-SCICAM-FLI': {
+ 'class': '0m4',
+ 'optical_elements': {
+ 'filters': [
+ { name: 'Filter D', code: 'FD', schedulable: true },
+ { name: 'Filter E', code: 'FE', schedulable: true }
+ ]
+ }
+ }
+ })
+ }
+ })
+
+ wrapper = mount(SchedulingSettings, {
+ global: {
+ plugins: [pinia],
+ props: {
+ showProjectField: true,
+ showTitleField: true,
+ target: 'Test Target'
+ }
+ }
+ })
+ })
+
+ it('calls fetchApiCall to get filter list on mount', async () => {
+ expect(fetchApiCall).toHaveBeenCalledWith(
+ expect.objectContaining({
+ url: 'http://mock-api.com/instruments',
+ method: 'GET',
+ successCallback: expect.any(Function),
+ failCallback: expect.any(Function)
+ })
+ )
+
+ await flushPromises()
+
+ // filters through the non-schedulable filters
+ expect(wrapper.vm.filterList).toEqual([
+ { name: 'Filter A', code: 'FA' },
+ { name: 'Filter D', code: 'FD' },
+ { name: 'Filter E', code: 'FE' }
+ ])
+
+ expect(fetchApiCall).toHaveBeenCalledTimes(1)
+ })
+
+ it('fetches RA and Dec based on the target name and updates state correctly', async () => {
+ const mockRaDecResponse = {
+ 'dec': '+41 16 07.50',
+ 'dec_d': 41.26875,
+ 'ra': '00 42 44.330',
+ 'ra_d': 10.684708
+ }
+
+ global.fetch = vi.fn(() =>
+ Promise.resolve({
+ json: () => Promise.resolve(mockRaDecResponse)
+ })
+ )
+
+ wrapper.vm.targetList[wrapper.vm.activeTargetIndex].name = 'Test Target'
+ await wrapper.vm.getRaDecFromTargetName()
+
+ await flushPromises()
+
+ // Verify the RA and Dec were updated to degrees
+ expect(wrapper.vm.targetList[wrapper.vm.activeTargetIndex].ra).toBe(0.7123333333333334)
+ expect(wrapper.vm.targetList[wrapper.vm.activeTargetIndex].dec).toBe(41.269)
+
+ expect(wrapper.vm.isTargetConfirmed).toBe(true)
+ })
+
+ it('displays an error if target name is invalid', async () => {
+ global.fetch = vi.fn(() =>
+ Promise.resolve({
+ json: () => Promise.resolve({})
+ })
+ )
+
+ // Simulate entering an invalid target name and triggering the blur event
+ wrapper.vm.targetList[wrapper.vm.activeTargetIndex].name = 'Invalid Target'
+ await wrapper.vm.getRaDecFromTargetName()
+
+ await flushPromises()
+
+ expect(wrapper.vm.targetError).toBe('Target not found, try another target.')
+ })
+
+ it('emits exposuresUpdated when exposures are added', async () => {
+ // Checks that filterList has been populated correctly
+ expect(wrapper.vm.filterList).toEqual([
+ { name: 'Filter A', code: 'FA' },
+ { name: 'Filter D', code: 'FD' },
+ { name: 'Filter E', code: 'FE' }
+ ])
+
+ // Simulates selecting a filter from the dropdown
+ wrapper.vm.settings.filter = 'FA'
+ wrapper.vm.settings.filterName = 'Filter A'
+ wrapper.vm.settings.exposureTime = '30'
+ wrapper.vm.settings.count = '15'
+
+ await wrapper.vm.addExposure()
+
+ // Check that the event is emitted with the expected payload
+ expect(wrapper.emitted().exposuresUpdated).toBeTruthy()
+ expect(wrapper.emitted().exposuresUpdated[0][0]).toEqual([
+ {
+ filter: 'FA',
+ filterName: 'Filter A',
+ exposureTime: '30',
+ count: '15'
+ }
+ ])
+ })
+})
diff --git a/src/tests/integration/components/schedulingView.test.js b/src/tests/integration/components/schedulingView.test.js
new file mode 100644
index 0000000..939b6a2
--- /dev/null
+++ b/src/tests/integration/components/schedulingView.test.js
@@ -0,0 +1,130 @@
+import { mount } from '@vue/test-utils'
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+import SchedulingView from '../../../components/Views/SchedulingView.vue'
+import { fetchApiCall } from '../../../utils/api.js'
+import { createTestStores } from '../../../utils/testUtils'
+import flushPromises from 'flush-promises'
+
+vi.mock('@/utils/api.js', () => ({
+ fetchApiCall: vi.fn()
+}))
+
+describe('SchedulingView.vue', () => {
+ let wrapper
+
+ beforeEach(() => {
+ fetchApiCall.mockClear()
+ const { pinia } = createTestStores()
+
+ wrapper = mount(SchedulingView, {
+ global: {
+ plugins: [pinia]
+ }
+ })
+ })
+
+ it('calls fetchApiCall to schedule observation', async () => {
+ const mockObservationData = {
+ target: { name: 'Test Target', ra: 180.0, dec: -20.0 },
+ settings: [
+ { filter: 'F1', exposureTime: 300, count: 1 }
+ ],
+ startDate: new Date(),
+ // 1 hour later
+ endDate: new Date(new Date().getTime() + 3600 * 1000)
+ }
+
+ const mockRequestList = [
+ {
+ acceptability_threshold: 90,
+ configuration_repeats: 1,
+ optimization_type: 'TIME',
+ configurations: [
+ {
+ type: 'EXPOSE',
+ instrument_type: '0M4-SCICAM-QHY600',
+ instrument_configs: [
+ {
+ exposure_count: 1,
+ exposure_time: 300,
+ mode: 'central30x30',
+ rotator_mode: '',
+ extra_params: {
+ offset_ra: 0,
+ offset_dec: 0,
+ defocus: 0
+ },
+ optical_elements: {
+ filter: 'F1'
+ }
+ }
+ ],
+ acquisition_config: {
+ mode: 'OFF',
+ extra_params: {}
+ },
+ guiding_config: {
+ mode: 'ON',
+ optional: true,
+ extra_params: {}
+ },
+ target: {
+ name: 'Test Target',
+ type: 'ICRS',
+ ra: 180.0,
+ dec: -20.0,
+ proper_motion_ra: null,
+ proper_motion_dec: null,
+ epoch: 2000,
+ parallax: null,
+ extra_params: {}
+ },
+ constraints: {
+ max_airmass: 1.6,
+ min_lunar_distance: 30,
+ max_lunar_phase: 1
+ }
+ }
+ ],
+ windows: [
+ {
+ // The slice is to remove milliseconds
+ start: mockObservationData.startDate.toISOString().slice(0, -5) + 'Z',
+ end: mockObservationData.endDate.toISOString().slice(0, -5) + 'Z'
+ }
+ ],
+ location: {
+ telescope_class: '0m4'
+ }
+ }
+ ]
+
+ fetchApiCall.mockImplementationOnce(({ successCallback }) => {
+ successCallback()
+ })
+
+ wrapper.vm.observationData = mockObservationData
+
+ await wrapper.vm.sendObservationRequest()
+
+ await flushPromises()
+
+ expect(fetchApiCall).toHaveBeenCalledWith({
+ url: 'https://observe.lco.global/api/requestgroups/',
+ method: 'POST',
+ body: {
+ name: 'UserObservation',
+ proposal: 'LCOSchedulerTest',
+ ipp_value: 1.05,
+ operator: 'SINGLE',
+ observation_type: 'NORMAL',
+ requests: mockRequestList
+ },
+ successCallback: expect.any(Function),
+ failCallback: expect.any(Function)
+ })
+
+ expect(fetchApiCall).toHaveBeenCalledTimes(1)
+ expect(wrapper.vm.showScheduled).toBe(true)
+ })
+})
diff --git a/src/tests/integration/components/upcomingBookings.test.js b/src/tests/integration/components/upcomingBookings.test.js
index 65e4c18..5e1faf5 100644
--- a/src/tests/integration/components/upcomingBookings.test.js
+++ b/src/tests/integration/components/upcomingBookings.test.js
@@ -22,19 +22,18 @@ const startTime2 = new Date(now + 45 * 60000).toISOString()
describe('UpcomingBookings.vue', () => {
let wrapper
- let sessionsStore
+ let obsPortalDataStore
beforeEach(() => {
vi.resetAllMocks()
- const { pinia, sessionsStore: store } = createTestStores()
- sessionsStore = store
+ const { pinia, obsPortalDataStore: store } = createTestStores()
+ obsPortalDataStore = store
- sessionsStore.sessions = {
- results: [
- { id: 'session1', start: startTime },
- { id: 'session2', start: startTime2 }
- ]
- }
+ // Mock the correct store property, `upcomingRealTimeSessions`
+ obsPortalDataStore.upcomingRealTimeSessions = [
+ { id: 'session1', start: startTime },
+ { id: 'session2', start: startTime2 }
+ ]
wrapper = mount(UpcomingBookings, {
global: {
@@ -45,7 +44,7 @@ describe('UpcomingBookings.vue', () => {
it('fetches sessions on mount', async () => {
expect(fetchApiCall).toHaveBeenCalled()
- expect(sessionsStore.sessions.results.length).toBe(2)
+ expect(obsPortalDataStore.upcomingRealTimeSessions.length).toBe(2)
await wrapper.vm.$nextTick()
@@ -56,9 +55,10 @@ describe('UpcomingBookings.vue', () => {
it('deletes a session on click', async () => {
fetchApiCall.mockImplementation(({ url }) => {
if (url.includes('session1')) {
- sessionsStore.sessions.results = sessionsStore.sessions.results.filter(session => session.id !== 'session1')
+ obsPortalDataStore.upcomingRealTimeSessions = obsPortalDataStore.upcomingRealTimeSessions.filter(session => session.id !== 'session1')
}
})
+
const deleteButtons = wrapper.findAll('.deleteButton')
expect(deleteButtons.length).toBe(2)
await deleteButtons.at(0).trigger('click')
@@ -68,6 +68,6 @@ describe('UpcomingBookings.vue', () => {
method: 'DELETE'
})
)
- expect(sessionsStore.sessions.results.length).toBe(1)
+ expect(obsPortalDataStore.upcomingRealTimeSessions.length).toBe(1)
})
})
diff --git a/src/tests/unit/utils/obsPortalDataStore.test.js b/src/tests/unit/utils/obsPortalDataStore.test.js
new file mode 100644
index 0000000..43e2f3a
--- /dev/null
+++ b/src/tests/unit/utils/obsPortalDataStore.test.js
@@ -0,0 +1,86 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { fetchApiCall } from '../../../utils/api.js'
+import { createTestStores } from '../../../utils/testUtils'
+
+vi.mock('@/utils/api', () => ({
+ fetchApiCall: vi.fn()
+}))
+
+describe('Observation Portal Data Store', () => {
+ let obsPortalDataStore
+
+ beforeEach(() => {
+ fetchApiCall.mockClear()
+ const { obsPortalDataStore: store } = createTestStores()
+ obsPortalDataStore = store
+ })
+
+ afterEach(() => {
+ vi.clearAllMocks()
+ })
+
+ it('fetches real time observations and normal observations and sorts them correctly in the store', async () => {
+ const now = new Date().getTime()
+
+ const mockResponse = {
+ results: [
+ {
+ id: 1,
+ // 2 hours ago (past session, REAL_TIME, should be fulfilled)
+ end: new Date(now - 2 * 60 * 60 * 1000).toISOString(),
+ state: 'PENDING',
+ observation_type: 'REAL_TIME'
+ },
+ {
+ id: 2,
+ // 30 minutes from now (upcoming session, REAL_TIME, should be in upcoming)
+ end: new Date(now + 30 * 60 * 1000).toISOString(),
+ state: 'PENDING',
+ observation_type: 'REAL_TIME'
+ },
+ {
+ id: 3,
+ // 1 hour ago (past session, COMPLETED NORMAL, should be fulfilled)
+ end: new Date(now - 60 * 60 * 1000).toISOString(),
+ state: 'COMPLETED',
+ observation_type: 'NORMAL'
+ }
+ ]
+ }
+
+ fetchApiCall.mockImplementationOnce(({ successCallback }) => {
+ successCallback(mockResponse)
+ })
+ await obsPortalDataStore.fetchCompleteObservationsAndUpcomingRTSessions()
+ expect(fetchApiCall).toHaveBeenCalledTimes(1)
+
+ // Check that completedObservations contains the COMPLETED NORMAL and past REAL_TIME observations
+ expect(obsPortalDataStore.completedObservations).toEqual({
+ 1: mockResponse.results[0],
+ 3: mockResponse.results[2]
+ })
+
+ // Check that upcomingRealTimeSessions contains the future REAL_TIME observation as an object
+ expect(obsPortalDataStore.upcomingRealTimeSessions).toEqual({
+ 2: mockResponse.results[1]
+ })
+ })
+
+ it('fetches pending requests (/requestgroups) and updates pendingRequestGroups correctly', async () => {
+ const mockPendingRequestsResults = {
+ results: [
+ { id: 1, state: 'PENDING' },
+ { id: 2, state: 'PENDING' }
+ ]
+ }
+
+ fetchApiCall.mockImplementationOnce(({ successCallback }) => {
+ successCallback(mockPendingRequestsResults)
+ })
+
+ await obsPortalDataStore.fetchPendingRequestGroups()
+
+ expect(fetchApiCall).toHaveBeenCalledTimes(1)
+ expect(obsPortalDataStore.pendingRequestGroups).toEqual(mockPendingRequestsResults.results)
+ })
+})
diff --git a/src/tests/unit/utils/realTimeSessionsStore.test.js b/src/tests/unit/utils/realTimeSessionsStore.test.js
new file mode 100644
index 0000000..a94f98a
--- /dev/null
+++ b/src/tests/unit/utils/realTimeSessionsStore.test.js
@@ -0,0 +1,86 @@
+import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { fetchApiCall } from '../../../utils/api.js'
+import { createTestStores } from '../../../utils/testUtils'
+import flushPromises from 'flush-promises'
+import { useObsPortalDataStore } from '../../../stores/obsPortalData' // Adjust the import path if necessary
+
+vi.mock('@/utils/api', () => ({
+ fetchApiCall: vi.fn()
+}))
+
+describe('Real Time Sessions Store', () => {
+ let realTimeSessionsStore
+ let obsPortalDataStore
+
+ beforeEach(() => {
+ fetchApiCall.mockClear()
+ const { realTimeSessionsStore: store } = createTestStores()
+ realTimeSessionsStore = store
+
+ // Set up the mock for useObsPortalDataStore
+ obsPortalDataStore = useObsPortalDataStore()
+ obsPortalDataStore.upcomingRealTimeSessions = {
+ 1: {
+ id: 1,
+ state: 'PENDING',
+ observation_type: 'REAL_TIME',
+ start: new Date(Date.now() + 15 * 60 * 1000).toISOString(), // 15 minutes from now
+ end: new Date(Date.now() + 30 * 60 * 1000).toISOString() // 30 minutes from now
+ }
+ }
+ })
+
+ afterEach(() => {
+ realTimeSessionsStore.stopPolling()
+ vi.clearAllMocks()
+ })
+
+ it('fetches session token correctly', async () => {
+ const mockTokenResponse = { token: 'mockedToken' }
+
+ realTimeSessionsStore.currentSessionId = 1
+ fetchApiCall.mockResolvedValueOnce(mockTokenResponse)
+
+ await realTimeSessionsStore.fetchSessionToken()
+ expect(realTimeSessionsStore.sessionTokens[1]).toBe('mockedToken')
+ })
+
+ it('starts polling and updates session status correctly', async () => {
+ const mockSessionStatusResponse = { session_status: 'ACTIVE' }
+ const mockTokenResponse = { token: 'mockToken' }
+
+ realTimeSessionsStore.currentSessionId = 1
+
+ fetchApiCall
+ // First API call (fetch token)
+ .mockResolvedValueOnce(mockTokenResponse)
+ // Second API call (first poll)
+ .mockResolvedValueOnce(mockSessionStatusResponse)
+ // Subsequent polls
+ .mockResolvedValue(mockSessionStatusResponse)
+
+ vi.useFakeTimers()
+
+ realTimeSessionsStore.startPolling()
+
+ // Fast forward the timer to simulate polling (10 seconds)
+ vi.advanceTimersByTime(10000)
+ await flushPromises()
+
+ expect(realTimeSessionsStore.currentStatus).toBe('ACTIVE')
+ // Token + first status fetch
+ expect(fetchApiCall).toHaveBeenCalledTimes(2)
+
+ // Fast-forward more time for the next polling iteration (1 second)
+ vi.advanceTimersByTime(1000)
+ await flushPromises()
+ // Token + two status fetches
+ expect(fetchApiCall).toHaveBeenCalledTimes(3)
+ vi.advanceTimersByTime(1000)
+ await flushPromises()
+ // Token + three status fetches
+ expect(fetchApiCall).toHaveBeenCalledTimes(4)
+
+ vi.useRealTimers()
+ }, 10000)
+})
diff --git a/src/utils/api.js b/src/utils/api.js
index e1aba3e..7093a05 100644
--- a/src/utils/api.js
+++ b/src/utils/api.js
@@ -1,18 +1,14 @@
/* eslint-disable no-unused-expressions */
import { useUserDataStore } from '../stores/userData.js'
-// import { useSessionsStore } from '../stores/sessions.js'
async function fetchApiCall ({ url, method, body = null, header, successCallback = null, failCallback = null }) {
const store = useUserDataStore()
- // const sessionsStore = useSessionsStore()
const defaultHeader = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
- // if (sessionsStore.getTokenForCurrentSession && url.match('session_status') && !url.match('login')) {
- // defaultHeader.Authorization = `Token ${sessionsStore.getTokenForCurrentSession}`
- // } else
+
if (store.authToken) {
defaultHeader.Authorization = `Token ${store.authToken}`
}
diff --git a/src/utils/testUtils.js b/src/utils/testUtils.js
index bcb3729..d4237f1 100644
--- a/src/utils/testUtils.js
+++ b/src/utils/testUtils.js
@@ -1,5 +1,6 @@
import { createPinia, setActivePinia } from 'pinia'
-import { useSessionsStore } from '../stores/sessions'
+import { useRealTimeSessionsStore } from '../stores/realTimeSessions'
+import { useObsPortalDataStore } from '../stores/obsPortalData'
import { useUserDataStore } from '../stores/userData'
import { useConfigurationStore } from '../stores/configuration'
@@ -8,7 +9,8 @@ export function createTestStores () {
setActivePinia(pinia)
// Create stores and set the necessary state for the tests
- const sessionsStore = useSessionsStore()
+ const realTimeSessionsStore = useRealTimeSessionsStore()
+ const obsPortalDataStore = useObsPortalDataStore()
const userDataStore = useUserDataStore()
const configurationStore = useConfigurationStore()
@@ -22,7 +24,8 @@ export function createTestStores () {
return {
pinia,
- sessionsStore,
+ realTimeSessionsStore,
+ obsPortalDataStore,
userDataStore,
configurationStore
}
+ Submit my request!
+
+
+
+ Submit my request!
+
+
+
+