So my question is, in the future, how can I more quickly decide if a bug is mine or the framework's?
The key is making the bug reproducible and isolated. In general you want to follow the same process initially whether you suspect the bug is yours or the libraries.
Stack Overflow's MCVE page is a great primer on this. SSCCE also attempts to speak to the same idea. Make an example that is simple and reliably reproduces the error.
As a simple example, imagine you have a an external method that is defined as:
Meteor.foo(int, int) // returns sum of two ints
You are using this method in your code, and suspect it is not working correctly. After following the MCVE process you arrive at the following code:
print Meteor.foo(0,2) // prints 0
print Meteor.foo(1,2) // prints 3
print Meteor.foo(2,0) // prints 2
This is now a compelling reason to believe that the Meteor library is causing the problem (obviously..). In this case it is clear how to write an example that is a "bug is not in my code" MCVE.
The point of all this is to narrow down your usage of your code until you find the minimal amount of code causing the problem. Trimming out extra code until you resolve the bug. If you can't trim anymore because of external library calls... probably found the problem.
Unfortunately, the reality is that nearly all bugs of this sort will not be as simple as that to reproduce. With these (and your MCVE or 'mostly MVCE' example) it's a good idea to:
- View release notes / known issues
- View open bugs
- Ask a question on Stack Overflow or the libraries listserve
- View the source code itself or what tests it has
There are other questions one, two about what to do once you arrive at the conclusion the bug is in the external library.
These sorts of problems can be really nasty when working with very expansive and commonly used libraries. We had an instance where multiple people were trying to track down a ship-block bug which ended up being a combination of a mouse driver causing the graphics to not render correctly with an external framework.