Description

This PR adds a new unit test project to the solution and grants that project access to the driver's internal types. The intention of this project is to hold strict unit tests that do not rely on outside resources (azure/local dbs, AKV, etc.). Tests in the unit test project are run as part of the pipeline, before functional tests.

Access to internal types is achieved using theInternalsVisibleTo assembly directive. Internal types must be included in the reference assembly for the project to compile via MSBuild. Automatic reference assembly generation is disabled to avoid conflicts between the auto generated and manually generated assemblies.

Many tests that currently live in the functional tests project could move to this project. I've left that as a future improvement to keep this change targeted.

Why is this important?

Today, most of our testing of internal types uses reflection, but this is problematic for a number of reasons:

• reflection is slow, error-prone, not type-safe, not refactor-safe, not discoverable (via IDE references), and increases friction to write tests
• usage of reflection as standard practice encourages access of truly private members of a class
  We need a better unit test setup where we can quickly and easily write comprehensive unit tests for internal classes.

Why not expose internals to integration tests (a.k.a manual tests)?

We could do this, but integration tests are the best way we have to test the public API of our driver. As much as possible, public API testing shouldn't invoke private/internal functionality to generate testing conditions. Integration tests should be stable even as internals are updated. I'm working towards the following testing methodology:

• Unit tests
  • lowest level
  • test units of code in isolation
  • fast
  • no external resources
  • access to internal types
• Integration tests
  • high level
  • test public API surfaces
  • slower
  • can use external resources
  • no access to internal types

Testing

I added one existing internal type to the reference assemblies and added a test to access that type to prove that internals are visible to the unit test project.

Guidelines

Please review the contribution guidelines before submitting a pull request:

• Contributing
• Code of Conduct
• Best Practices
• Coding Style
• Review Process