summaryrefslogtreecommitdiff
path: root/platform/node/test/js/gzip.test.js
blob: 4545a18cf591373fb3fed1ae9f45b10da2b7b6fe (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
'use strict';

/* jshint node: true */

var test = require('tape').test;
var mbgl = require('../../../..');
var fs = require('fs');
var path = require('path');
var mkdirp = require('mkdirp');
var http = require('http');
var request = require('request');
var st = require('st');
var style = require('../fixtures/style.json');
var PNG = require('pngjs').PNG;
var compare = require('../compare.js');

var server = http.createServer(st({ path: path.join(__dirname, '..') }));
server.listen(0);

function filePath(name) {
    return ['expected', 'actual', 'diff'].reduce(function(prev, key) {
        var dir = path.join(__dirname, '..', key, 'gzip');
        mkdirp.sync(dir);
        prev[key] = path.join(dir, name);
        return prev;
    }, {});
}

function setup(options, callback) {
    callback(new mbgl.Map(options));
}

function getOptions(gzip, t) {
    return {
        request: function(req) {
            var parts = req.url.split('.');
            var filetype = parts[parts.length - 1];

            request({
                url: 'http://localhost:' + server.address().port + path.join('/', req.url),
                encoding: null,
                gzip: filetype === 'pbf' ? gzip : true,
                headers: {
                    'Accept-Encoding': 'gzip'
                }
            }, function (err, res, body) {
                t.error(err);
                var response = {};
                response.data = res.body;
                req.respond(null, response);
            });
        },
        ratio: 1.0
    };
}

test('gzip', function(t) {
    t.test('success', function(t) {
        mbgl.on('message', function(msg) {
            if (msg.severity == 'ERROR') t.error(msg);
        });

        setup(getOptions(true, t), function(map) {
            map.load(style);
            map.render({}, function(err, data) {
                mbgl.removeAllListeners('message');
                map.release();

                t.error(err);

                var filename = filePath('success.png');

                var png = new PNG({
                    width: data.width,
                    height: data.height
                });

                png.data = data.pixels;

                if (process.env.UPDATE) {
                    png.pack()
                        .pipe(fs.createWriteStream(filename.expected))
                        .on('finish', t.end);
                } else {
                    png.pack()
                        .pipe(fs.createWriteStream(filename.actual))
                        .on('finish', function() {
                            compare(filename.actual, filename.expected, filename.diff, t, function(err, diff) {
                                t.error(err);
                                t.ok(diff <= 0.01, 'actual matches expected');
                                t.end();
                            });
                        });
                }
            });
        });
    });

    t.test('unhandled', function(t) {
        mbgl.once('message', function(msg) {
            if (msg.severity == 'ERROR') {
                t.ok(msg, 'emits error');
                t.equal(msg.class, 'Style');
                t.equal(msg.severity, 'ERROR');
                t.ok(msg.text.match(/pbf unknown field type exception/), 'error text matches');
            }
        });

        setup(getOptions(false, t), function(map) {
            map.load(style);
            map.render({}, function(err, data) {
                map.release();

                t.ok(err, 'returns error');
                t.ok(err.message.match(/Failed to parse/), 'error text matches');

                t.end();
            });
        });
    });

    t.test('teardown', function(t) {
        server.close(t.end);
    });
});