Software Quality Assurance Plan

In order to test our backend software's functionality, the team split in half. Binyuan, Tritin, and Yang are working on the software implementation, while Zirui and Mark work on creating the tests. This split allows us to write some of the tests without bias from knowing how the code actually works (closer to black box testing).

Broadly, we have 2 types of tests to do:

• Unit Tests - ensuring that each class works and is correctly synchronized with the databases (CRUD operations are valid)
  1. We can create instances for each of our classes (Student, Document, ApplicationForm, Reminder, Internship, Course)
  2. We can read fields associated with those instances
  3. We can update those same fields
  4. By this point in the project, we did not implement delete operations for many of the classes, since we did not find it to be necessary (update usually accomplishes a similar goal but better)
• Integration/Acceptance Tests - ensuring that all the use cases are satisfied
  1. User (student) can upload, read, and overwrite documents with the service
  2. User can view progress through their Co-Op program (read Courses and Internships)
  3. User can read and receive notifications

Although we already tested some of these unit tests for the first deliverable, we ended up changing a decent amount of our code structure so we will need to retest most of it.

We will be using JUnit4 for most of the unit tests, and we will also use EclEmma for code coverage. In order to further isolate our unit tests, we will be using mock objects for our dependencies (using Mockito).

To assess the quality of our tests, we will be looking at the code coverage. Ideally, each test would have 100% coverage of the parts that they test, and the sum of all our tests would completely cover all of the working code, but this is impractical and not necessarily essential (e.g. some classes has null constructors that don't need to be tested).

With our test suite, we verified 2048/2797 instructions in our main folder, for a 73.2% coverage.

To improve the quality of our code, we tried to follow some basic style conventions (e.g. making sure that final variables are capitalized). Furthermore, Binyuan - our CTO and most experienced member - examined and refactored a lot of our code to ensure consistency.