expand functional test routes

Author: jclark118

service/functionalTests/client.ts

@@ -228,6 +228,86 @@ export class MageClientSession {
     return this.http.get<Observation>(`/api/events/${eventId}/observations/${observationId}`).then(x => x.data)
   }
 
+  favoriteObservation(eventId: MageEventId, observationId: ObservationId): Promise<AxiosResponse<Observation>> {
+    return this.http.put(`/api/events/${eventId}/observations/${observationId}/favorite`)
+  }
+
+  unfavoriteObservation(eventId: MageEventId, observationId: ObservationId): Promise<AxiosResponse<Observation>> {
+    return this.http.delete(`/api/events/${eventId}/observations/${observationId}/favorite`)
+  }
+
+  markImportant(eventId: MageEventId, observationId: ObservationId, description?: string): Promise<AxiosResponse<Observation>> {
+    return this.http.put(`/api/events/${eventId}/observations/${observationId}/important`, description ? { description } : {})
+  }
+
+  unmarkImportant(eventId: MageEventId, observationId: ObservationId): Promise<AxiosResponse<Observation>> {
+    return this.http.delete(`/api/events/${eventId}/observations/${observationId}/important`)
+  }
+
+  addObservationState(eventId: MageEventId, observationId: ObservationId, name: 'active' | 'archive'): Promise<AxiosResponse<ObservationState>> {
+    return this.http.post(`/api/events/${eventId}/observations/${observationId}/states`, { name })
+  }
+
+  listUsers(query?: Record<string, string>): Promise<AxiosResponse<User[]>> {
+    return this.http.get('/api/users', { params: query })
+  }
+
+  getUser(userId: UserId): Promise<AxiosResponse<User>> {
+    return this.http.get(`/api/users/${userId}`)
+  }
+
+  updateUser(userId: UserId, attrs: Partial<UserCreateRequest>): Promise<AxiosResponse<User>> {
+    const form = new FormData()
+    for (const [key, val] of Object.entries(attrs)) {
+      if (val != null) {
+        form.set(key, String(val))
+      }
+    }
+    return this.http.put(`/api/users/${userId}`, form)
+  }
+
+  getMyself(): Promise<AxiosResponse<User>> {
+    return this.http.get('/api/users/myself')
+  }
+
+  updateMyself(attrs: Partial<Pick<User, 'displayName' | 'email'>>): Promise<AxiosResponse<User>> {
+    const form = new FormData()
+    for (const [key, val] of Object.entries(attrs)) {
+      if (val != null) {
+        form.set(key, String(val))
+      }
+    }
+    return this.http.put('/api/users/myself', form)
+  }
+
+  createTeam(attrs: TeamCreateRequest): Promise<AxiosResponse<Team>> {
+    return this.http.post('/api/teams', attrs)
+  }
+
+  listTeams(query?: Record<string, string>): Promise<AxiosResponse<Team[]>> {
+    return this.http.get('/api/teams', { params: query })
+  }
+
+  getTeam(teamId: Team['id']): Promise<AxiosResponse<Team>> {
+    return this.http.get(`/api/teams/${teamId}`)
+  }
+
+  updateTeam(teamId: Team['id'], attrs: Partial<TeamCreateRequest>): Promise<AxiosResponse<Team>> {
+    return this.http.put(`/api/teams/${teamId}`, attrs)
+  }
+
+  deleteTeam(teamId: Team['id']): Promise<AxiosResponse<Team>> {
+    return this.http.delete(`/api/teams/${teamId}`)
+  }
+
+  addTeamMember(teamId: Team['id'], userId: UserId): Promise<AxiosResponse<Team>> {
+    return this.http.post(`/api/teams/${teamId}/users`, { id: userId })
+  }
+
+  removeTeamMember(teamId: Team['id'], userId: UserId): Promise<AxiosResponse<Team>> {
+    return this.http.delete(`/api/teams/${teamId}/users/${userId}`)
+  }
+
   postUserLocations(eventId: number, locations: Array<[lon: number, lat: number, timestamp?: number | undefined]>): Promise<AxiosResponse<UserLocation[]>> {
     const features = locations.map<geojson.Feature<geojson.Point>>(([lon, lat, timestamp]) => {
       if (typeof timestamp !== 'number') {
@@ -675,6 +755,18 @@ export interface Attachment {
   url?: string
 }
 
+export interface ObservationState {
+  name: 'active' | 'archive'
+  userId?: UserId
+  timestamp?: ISODateString
+}
+
+export interface TeamCreateRequest {
+  name: string
+  description?: string
+  userIds?: UserId[]
+}
+
 export interface ObservationImportantFlag {
   userId?: UserId
   user?: UserLite

service/functionalTests/observations/fixture.ts

@@ -0,0 +1,72 @@
+
+import { expect } from 'chai'
+import {
+  MageClientSession,
+  RootUserSetupRequest,
+  MageEventCreateRequest,
+  MageFormCreateRequest,
+  MageEventPopulated,
+  MageForm,
+  Observation,
+  FormFieldType,
+} from '../client'
+
+export const rootSeed: RootUserSetupRequest = {
+  username: 'obs.root',
+  displayName: 'Observations Root',
+  password: 'obs.root.secret',
+  uid: 'obs.root.device',
+}
+
+export const eventSeed: MageEventCreateRequest = {
+  name: 'Observation Test Event',
+  style: {},
+}
+
+export const formSeed: MageFormCreateRequest = {
+  name: 'obs_form',
+  userFields: [],
+  archived: false,
+  color: '#aa0000',
+  fields: [
+    {
+      id: 1,
+      name: 'title',
+      required: false,
+      title: 'Title',
+      type: FormFieldType.Text,
+    },
+  ],
+}
+
+export interface ObservationFixture {
+  event: MageEventPopulated
+  form: MageForm
+  observation: Observation
+}
+
+export async function populateFixtureData(rootSession: MageClientSession): Promise<ObservationFixture> {
+
+  const event = await rootSession.createEvent(eventSeed).then(x => x.data)
+
+  expect(event.id).to.be.a('number')
+
+  const form = await rootSession.createForm(event.id, formSeed).then(x => x.data)
+  const eventWithForms = await rootSession.readEvent(event.id).then(x => x.data)
+  await rootSession.addParticipantToEvent(eventWithForms, rootSession.user!.id)
+
+  const observation = await rootSession.saveObservation({
+    id: null,
+    type: 'Feature',
+    geometry: { type: 'Point', coordinates: [-104.9352, 39.6285] },
+    eventId: event.id,
+    properties: {
+      timestamp: new Date().toISOString(),
+      forms: [{ formId: form.id, title: 'Test Observation' }],
+    },
+  })
+
+  expect(observation.id).to.be.a('string')
+
+  return { event: eventWithForms, form, observation }
+}

service/functionalTests/observations/observations.test.ts

@@ -0,0 +1,96 @@
+
+// list observations in event
+// read observation by id
+// favorite an observation
+// unfavorite an observation
+// mark observation as important
+// unmark observation as important
+// transition observation state to archived
+// transition observation state to active
+
+import { expect } from 'chai'
+import { MageClientSession, SignInResult } from '../client'
+import { ChildProcessTestStackRef, launchTestStack } from '../stack'
+import * as Fixture from './fixture'
+
+
+describe('observations', function () {
+
+  let stack: ChildProcessTestStackRef
+  let rootSession: MageClientSession
+  let fixture: Fixture.ObservationFixture
+
+  this.timeout(15000)
+
+  before('initialize stack', async function () {
+    stack = await launchTestStack('observations')
+  })
+
+  before('initialize fixture data', async function () {
+
+    rootSession = new MageClientSession(stack.mageUrl)
+    const rootSetup = await rootSession.setupRootUser(Fixture.rootSeed).then(x => x.data)
+
+    expect(rootSetup.user.username).to.equal(Fixture.rootSeed.username)
+    expect(rootSetup.device.uid).to.equal(Fixture.rootSeed.uid)
+
+    const rootSignIn = await rootSession.signIn(Fixture.rootSeed.username, Fixture.rootSeed.password, Fixture.rootSeed.uid) as SignInResult
+
+    expect(rootSignIn.user).to.exist
+    expect(rootSignIn.user.username).to.equal(Fixture.rootSeed.username)
+
+    fixture = await Fixture.populateFixtureData(rootSession)
+  })
+
+  after('stop stack', async function () {
+    await stack.stop()
+  })
+
+  it('lists observations in event', async function () {
+    const observations = await rootSession.readObservations(fixture.event.id)
+
+    expect(observations).to.be.an('array').with.length.greaterThan(0)
+    const found = observations.find(o => o.id === fixture.observation.id)
+    expect(found, 'fixture observation not in list').to.exist
+  })
+
+  it('reads observation by id', async function () {
+    const obs = await rootSession.readObservation(fixture.event.id, fixture.observation.id)
+
+    expect(obs.id).to.equal(fixture.observation.id)
+    expect(obs.eventId).to.equal(fixture.event.id)
+    expect(obs.geometry.type).to.equal('Point')
+  })
+
+  it('favorites and unfavorites an observation', async function () {
+    const { event, observation } = fixture
+
+    const favorited = await rootSession.favoriteObservation(event.id, observation.id).then(x => x.data)
+    expect(favorited.favoriteUserIds).to.include(rootSession.user!.id)
+
+    const unfavorited = await rootSession.unfavoriteObservation(event.id, observation.id).then(x => x.data)
+    expect(unfavorited.favoriteUserIds).not.to.include(rootSession.user!.id)
+  })
+
+  it('marks and unmarks an observation as important', async function () {
+    const { event, observation } = fixture
+    const description = 'High priority incident'
+
+    const marked = await rootSession.markImportant(event.id, observation.id, description).then(x => x.data)
+    expect(marked.important).to.exist
+    expect(marked.important!.description).to.equal(description)
+
+    const unmarked = await rootSession.unmarkImportant(event.id, observation.id).then(x => x.data)
+    expect(unmarked.important).not.to.exist
+  })
+
+  it('adds observation state transitions', async function () {
+    const { event, observation } = fixture
+
+    const archived = await rootSession.addObservationState(event.id, observation.id, 'archive').then(x => x.data)
+    expect(archived.name).to.equal('archive')
+
+    const reactivated = await rootSession.addObservationState(event.id, observation.id, 'active').then(x => x.data)
+    expect(reactivated.name).to.equal('active')
+  })
+})

service/functionalTests/teams/fixture.ts

@@ -0,0 +1,55 @@
+
+import { expect } from 'chai'
+import {
+  MageClientSession,
+  RootUserSetupRequest,
+  UserCreateRequest,
+  User,
+  Team,
+  TeamCreateRequest,
+} from '../client'
+
+export const rootSeed: RootUserSetupRequest = {
+  username: 'teams.root',
+  displayName: 'Teams Root',
+  password: 'teams.root.secret',
+  uid: 'teams.root.device',
+}
+
+export const userSeed: Omit<UserCreateRequest, 'roleId'> = {
+  username: 'teams.testuser',
+  displayName: 'Teams Test User',
+  password: 'testuser.secret_password',
+}
+
+export const teamSeed: TeamCreateRequest = {
+  name: 'Fixture Team',
+  description: 'Created by functional test fixture',
+}
+
+export interface TeamsFixture {
+  additionalUser: User
+  team: Team
+}
+
+export async function populateFixtureData(rootSession: MageClientSession): Promise<TeamsFixture> {
+
+  const roles = await rootSession.listRoles().then(x => x.data)
+  const userRole = roles.find(x => x.name === 'USER_ROLE')!
+
+  expect(userRole, 'failed to find user role').to.exist
+
+  const additionalUser = await rootSession.createUser({
+    ...userSeed,
+    roleId: userRole.id,
+  }).then(x => x.data)
+
+  expect(additionalUser.id, 'additional user missing id').to.be.a('string')
+
+  const team = await rootSession.createTeam(teamSeed).then(x => x.data)
+
+  expect(team.id, 'team missing id').to.be.a('string')
+  expect(team.name).to.equal(teamSeed.name)
+
+  return { additionalUser, team }
+}