Meteor test driven development [closed]

Question

Update 3: As of Meteor 1.3, meteor includes a testing guide with step-by-step instructions for unit, integration, acceptance, and load testing.

Update 2: As of November 9th, 2015, Velocity is no longer maintained. Xolv.io is focusing their efforts on Chimp, and the Meteor Development Group must choose an official testing framework.

Update: Velocity is Meteor's official testing solution as of 0.8.1.

---

Not much has been written about automated testing with Meteor at this time. I expect the Meteor community to evolve testing best-practices before establishing anything in the official documentation. After all, Meteor reached 0.5 this week, and things are still changing rapidly.

The good news: you can use Node.js testing tools with Meteor.

For my Meteor project, I run my unit tests with Mocha using Chai for assertions. If you don't need Chai's full feature set, I recommend using should.js instead. I only have unit tests at the moment, though you can write integration tests with Mocha as well.

Be sure to place your tests in the "tests" folder so that Meteor does not attempt to execute your tests.

Mocha supports CoffeeScript, my choice of scripting language for Meteor projects. Here's a sample Cakefile with tasks for running your Mocha tests. If you are using JS with Meteor, feel free to adapt the commands for a Makefile.

Your Meteor models will need a slight bit of modification to expose themselves to Mocha, and this requires some knowledge of how Node.js works. Think of each Node.js file as being executed within its own scope. Meteor automatically exposes objects in different files to one another, but ordinary Node applications—like Mocha—do not do this. To make our models testable by Mocha, export each Meteor model with the following CoffeeScript pattern:

# Export our class to Node.js when running
# other modules, e.g. our Mocha tests
#
# Place this at the bottom of our Model.coffee
# file after our Model class has been defined.
exports.Model = Model unless Meteor?

...and at the top of your Mocha test, import the model you wish to test:

# Need to use Coffeescript's destructuring to reference
# the object bound in the returned scope
# http://coffeescript.org/#destructuring
{Model} = require '../path/to/model'

With that, you can start writing and running unit tests with your Meteor project!

Hi all checkout laika - the whole new testing framework for meteor http://arunoda.github.io/laika/

You can test both the server and client at once.

• See some laika example here
• See here for features
• See concept behind laika
• See Github Repository

Disclaimer: I'm the author of Laika.

I realize that this question is already answered, but I think this could use some more context, in the form of an additional answer providing said context.

I've been doing some app development with meteor, as well as package development, both by implementing a package for meteor core, as well as for atmosphere.

It sounds like your question might be actually a question in three parts:

1. How does one run the entire meteor test suite?
2. How does one write and run tests for individual smart packages?
3. How does one write and run tests for his own application?

And, it also sounds like there may be a bonus question in there somewhere: 4. How can one implement continuous integration for 1, 2, and 3?

I have been talking and begun collaborating with Naomi Seyfer (@sixolet) on the meteor core team to help get definitive answers to all of these questions into the documentation.

I had submitted an initial pull request addressing 1 and 2 to meteor core: https://github.com/meteor/meteor/pull/573.

I had also recently answered this question: How do you run the meteor tests?

I think that @Blackcoat has definitively answered 3, above.

As for the bonus, 4, I would suggest using circleci.com at least to do continuous integration for your own apps. They currently support the use case that @Blackcoat had described. I have a project in which I've successfully gotten tests written in coffeescript to run unit tests with mocha, pretty much as @Blackcoat had described.

For continuous integration on meteor core, and smart packages, Naomi Seyfer and I are chatting with the founder of circleci to see if we can get something awesome implemented in the near term.

RTD has now been deprecated and replaced by Velocity, which is the official testing framework for Meteor 1.0. Documentation is still relatively new as Velocity is under heavy development. You can find some more information on the Velocity Github repo, the Velocity Homepage and The Meteor Testing Manual (paid content)

Disclaimer: I'm one of the core team members of Velocity and the author of the book.

---

Check out RTD, a full testing framework for Meteor here rtd.xolv.io. It supports Jasmine/Mocha/custom and works with both plain JS and coffee. It includes test coverage too that combines unit/server/client coverage.

And an example project here

A blog to explain unit testing with Meteor here

An e2e acceptance testing approach using Selenium WebdriverJS and Meteor here

Hope that helps. Disclaimer: I am the author of RTD.

I used this page a lot and tried all of the answers, but from my beginner's starting point, I found them quite confusing. Once I had any trouble, I was flummoxed as to how to fix them.

This solution is really simple to get started with, if not fully documented yet, so I recommend it for people like myself who want to do TDD but aren't sure how testing in JavaScript works and which libraries plug into what:

https://github.com/mad-eye/meteor-mocha-web

FYI, I found that I also need to use the router Atmosphere package to make a '/tests' route to run and display the results from the tests, as I didn't want it to clutter my app every time it loads.

About the usage of tinytest, you may want to take a look at those useful ressources:

1. The basics are explained in this screencast: https://www.eventedmind.com/feed/meteor-testing-packages-with-tinytest

2. Once you understood the idea, you'll want the public API documentation for tinytest. For now, the only documentation for that is at the end of the source of the tinytest package: https://github.com/meteor/meteor/tree/devel/packages/tinytest

3. Also, the screencast talks about test-helpers, you may want to have a look at all the available helpers in here: https://github.com/meteor/meteor/tree/devel/packages/test-helpers There often is some documentation inside each file

4. Digging in the existing tests of meteor's packages will provide a lot of examples. One way of doing this is to make a search for Tinytest. or test. in the package directory of meteor's source code

Testing becomes a core part of Meteor in the upcoming 1.3 release. The initial solution is based on Mocha and Chai.

The original discussions of the minimum viable design can be found here and the details of the first implementation can be found here.

MDG have produced the initial bones of the guide documentation for the testing which can be found here, and there are some example tests here.

This is an example of a publication test from the link above:

  it('sends all todos for a public list when logged in', (done) => {
    const collector = new PublicationCollector({userId});
    collector.collect('Todos.inList', publicList._id, (collections) => {
      chai.assert.equal(collections.Todos.length, 3);
      done();
    });
  });