File: redirects.js

package info (click to toggle)
node-superagent 9.0.1-2
  • links: PTS, VCS
  • area: main
  • in suites: sid, trixie
  • size: 3,464 kB
  • sloc: javascript: 11,641; makefile: 77
file content (141 lines) | stat: -rw-r--r-- 3,632 bytes parent folder | download | duplicates (2)
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
const assert = require('assert');

const getSetup = require('./support/setup');
const request = require('./support/client');

describe('request', function () {
  let setup;
  let base;
  let isMSIE;

  before(async () => {
    setup = await getSetup();
    base = setup.uri;
    isMSIE = !setup.NODE && /Trident\//.test(navigator.userAgent);
  });

  this.timeout(20_000);
  describe('on redirect', () => {
    it('should retain header fields', (done) => {
      request
        .get(`${base}/header`)
        .set('X-Foo', 'bar')
        .end((error, res) => {
          try {
            assert(res.body);
            res.body.should.have.property('x-foo', 'bar');
            done();
          } catch (err) {
            done(err);
          }
        });
    });

    it('should preserve timeout across redirects', (done) => {
      request
        .get(`${base}/movies/random`)
        .timeout(250)
        .end((error, res) => {
          try {
            assert(error instanceof Error, 'expected an error');
            error.should.have.property('timeout', 250);
            done();
          } catch (err) {
            done(err);
          }
        });
    });

    it('should successfully redirect after retry on error', (done) => {
      const id = Math.random() * 1_000_000 * Date.now();
      request
        .get(`${base}/error/redirect/${id}`)
        .retry(2)
        .end((error, res) => {
          assert(res.ok, 'response should be ok');
          assert(res.text, 'first movie page');
          done();
        });
    });

    it('should preserve retries across redirects', (done) => {
      const id = Math.random() * 1_000_000 * Date.now();
      request
        .get(`${base}/error/redirect-error${id}`)
        .retry(2)
        .end((error, res) => {
          assert(error, 'expected an error');
          assert.equal(2, error.retries, 'expected an error with .retries');
          assert.equal(500, error.status, 'expected an error status of 500');
          done();
        });
    });
  });

  describe('on 303', () => {
    it('should redirect with same method', (done) => {
      request
        .put(`${base}/redirect-303`)
        .send({ msg: 'hello' })
        .redirects(1)
        .on('redirect', (res) => {
          res.headers.location.should.equal('/reply-method');
        })
        .end((error, res) => {
          if (error) {
            done(error);
            return;
          }

          res.text.should.equal('method=get');
          done();
        });
    });
  });

  describe('on 307', () => {
    it('should redirect with same method', (done) => {
      if (isMSIE) return done(); // IE9 broken

      request
        .put(`${base}/redirect-307`)
        .send({ msg: 'hello' })
        .redirects(1)
        .on('redirect', (res) => {
          res.headers.location.should.equal('/reply-method');
        })
        .end((error, res) => {
          if (error) {
            done(error);
            return;
          }

          res.text.should.equal('method=put');
          done();
        });
    });
  });

  describe('on 308', () => {
    it('should redirect with same method', (done) => {
      if (isMSIE) return done(); // IE9 broken

      request
        .put(`${base}/redirect-308`)
        .send({ msg: 'hello' })
        .redirects(1)
        .on('redirect', (res) => {
          res.headers.location.should.equal('/reply-method');
        })
        .end((error, res) => {
          if (error) {
            done(error);
            return;
          }

          res.text.should.equal('method=put');
          done();
        });
    });
  });
});