Standardized (Human) Testing Protocol to outline steps to check main features

[doomlab]

A list of things we can test (just making a starting list):

• can you log in?
• can you change the theme?
• is there a overall dashboard with stuff on it?
  • can you move stuff on the dashboard around?
• click through sidebar options to ensure they populate on overall dashboard
• can you create a form?
  • can you edit a form?
• can you create a role?
  • can you edit a role?
• can you create a project?
  • do you get a dashboard that you can move stuff around on?
  • does that update with new added tasks?
  • can you update the project information?
• can you send an announcement?
• can you create an element?
  • is there a dashboard that appears?
  • can you update an element?
• can you add a task?
  • can you assign a person and team
  • can you add form data requirement
  • can you edit a task
  • ensure the task dashboard shows the task and the right information (username)
  • look at task history and complete the task
  • make sure the task appears on the table and kanban board
  • can you edit the task data (as PM)
• add roles to contributor and task
• add a contributor to the project
• add a team to the project
  • check team contribution page
• check form data from a task
  • can you edit the form data?
  • can you download the form data?
  • view the task dashboard (shows right names and information)
  • view the history of the task
• view announcements (do they appear right)
• view summary and make sure it is changeable view drop down

[chartgerink]

Great first list! In terms of unit testing, I can imagine the following can be best tested directly:

1. mutations/queries
2. components

In that sense, checking whether form data can be edited for example, could be a part of a unit test of that component. The biggest thing that would be left for a (human) testing protocol are those that combine across components, queries/mutations at the same time. These you could cover with integration tests, but I would recommend to stick to implementing one type of test first 😊

[doomlab]

What we've done so far:

• Reviewed how to do unit tests in blitz vitesthttps://blitzjs.com/docs/testing

Notes from meeting: (how to approach)

• be sure to break this down so it's not such a large task
• what is the scope of the testing and start identifying where those tests should be directed at (is that feasible within the time frame)
• keep the scale of a test contained focus on unit tests (not integration tests yet)
• set up the environment --> making sure they work, make sure they fail successfully (make sure the signal is appropriate, like the test is useful and feedback is useful)

What is the scope and what is the work?

• test components to ensure they render (2 weeks)
• what are important scenarios to test for
• what are useful informative tests to examine

Do we need support on building these?

• component rendering should be the "training wheels"
• five to ten components in two weeks (in the components folder)
• removing components that aren't being used
• project list component
• starting with tasks, assignments

[doomlab]

what kinds of tests would be helpful information on queries or mutations?

• validity of queries (i know there are three and i got three back)

• i asked for 4 rows and did i get four back

• what are risky ways the system might break

• can users run queries to begin with ? (too buggy)

• If logged in - can you only request your own data --> can people mess around query

• code that gets reused a lot is a good place to test

• figure out the scoping - at what level of specificity should the test lie

• SMART - specific enough the test is informative - specific to one piece at a time

• [ ] who does this task?

• [ ] everyone should come up with a list of things to test

[chartgerink]

@doomlab may these last few comments be more applicable in #156? I thought this item was more about a protocol to test those things that we do not include in the unit tests (for example, the process of signing up and creating a project altogether).