Alicia Sykes's Blog

• Identify failures in our code BEFORE it gets integrated with the larger application
• Allows you to continue verifying that your method still works as expected in all (tested) cases while your refactor/ change the logic in the methods body
• If your approaching development from a unit test perspective, you'll likely be writing code that is easier to test - more modular, clear, standalone methods - this is better code.
• Prevent future changes from breaking functionality.
• They help you really understand the design of your code
• They give you instant feedback, and that green tick when they all pass is so satisfying!
• Faster to develop more robust code
• They can help with code reuse
• Forces better code documentation

Disadvantages of Unit Testing

A good unit test is:

Links for Further Reading

istanbul cover test/my-test.js

"scripts": {
    "start": "node app.js",
    "test": "mocha",
    "cover": "istanbul cover node_modules/mocha/bin/_mocha --dir ./reports/coverage"
  }

npm run cover

npm install mocha --global

npm init

npm install mocha --save-dev

mkdir test

mkdir test-example && cd test-example :: create new projet director

npm i mocha -g :: install mocha globally so the mocha command can be used

npm init :: initialise package.json

npm i mocha -D ::  add mocha to your projects devDependancies

mkdir test :: create new folder for tests

npm install chai --save-dev

var chai = require('chai');

var expect = chai.expect;

describe('JavaScript example test', function(){
    it('should return true in JavaScript',function(){
        expect(true).equal(true);
    });
});

expect(foo).to.be.a('string');
expect(foo).to.equal('bar');
expect(foo).to.have.length(3);
expect(tea).to.have.property('flavors')
  .with.length(3);

3. Running Tests, and specifying additional options

mocha

Running tests from a single file

Specifying test path in package.json

"scripts": {
    "start": "node ./bin/www",
    "test": "mocha",
  }

Passing additional parameters to mocha

mocha --reporter nyan --recursive

4. Coverage Testing

• Documentation code
• Catch future errors
• Long-term time savings - because errors have been found before anythings been deployed to production

• Decide what the code will do
• Write a test that will pass if the code does that thing
• Run the test, to prove it will fail
• Write the code
• Run the test again, to see it pass

• Design and plan before you code
• Documenting your design before you build it
• Proving that the code implements that design
• Encouraging the design of testable code - very important!!

• Modular, as we're forced to break things down so we can test them
• Decoupled design, if our objects or methods are too tightly interwoven, we can't test them independantly.
• Methods should have limited scope, and not trying to do too much in one place
• etc... 

• Some things are too hard to test - especially where external services are involved
• Some tests are too trivial to be useful
• Over-testing is possible 
• Exploritory codeing, whern your not sure how it's going to be used. SO not for production code.

Links for learning more about TDD

How to write the gulpfile.js

npm install gulp --save-dev

npm install gulp-sass --save-dev

Require Necessary Modules

var gulp = require('gulp');

var sass = require('gulp-sass');

Creating a gulp task

gulp.task('sass', function() {
    return gulp.src('scss/*.scss')
        .pipe(sass())
        .pipe(gulp.dest('css'));
});

Running the Gulp task

gulp sass

Watching files for changes

gulp.task('watch', function() {
    gulp.watch('scss/*.scss', ['sass']);
});

gulp.watch('cscripts/*.coffee', ['coffee']);

Including Multiple Plugins in a single task

gulp.task('scripts', function() {
    return gulp.src('js/*.js')
        .pipe(concat('all.js'))
        .pipe(gulp.dest('dist'))
        .pipe(rename('all.min.js'))
        .pipe(uglify())
        .pipe(gulp.dest('dist'));
});

Default Task

gulp

gulp.task('default', ['sass', 'lint', 'coffee', 'watch']);

Prerequisite Tasks

gulp.task('coffee', ['coffee-lint'], function(){
return gulp.src('cs/*.coffee')
        .pipe(coffee())
        .pipe(gulp.dest('dist'));
});

Setting up example project

1. Open the console and navigate into a new working directory
2. Run the command: git clone https://github.com/Lissy93/gulp-example.git
3. Install the dependencies by running: npm install
4. Start the gulp script bu running: gulp

Voice Interaction

Finger Printing

Backup

Google Play Services

Power

Data Binding

UI Features

Notications

Text

App Links

Direct Share

Better Stylus Support

Graphics and Media

Alpha Optimisation

MIDI

Android Studio 1.3

Parse.Cloud.define("sendMail", function(request, response) {
    var Mandrill = require('mandrill');
    Mandrill.initialize('<Manddrill_api_key>');
    Mandrill.sendEmail({
        message: {
            text: request.params.text,
            subject: request.params.subject,
            from_email: request.params.fromEmail,
            from_name: request.params.fromName,
            to: [{
                email: request.params.toEmail,
                name: request.params.toName
            }]
        },
        async: true
    }, {
        success: function(httpResponse) {
            console.log(httpResponse);
            response.success("Email sent!");
        },
        error: function(httpResponse) {
            console.error(httpResponse);
            response.error("ERROR - mail failed to send");
        }
    });
});