提供的测试文件中的_user是什么？

Question

雇主给了我一个测试项目，他为我的应用程序提供了一些测试。当我到达最后一个的时候，我得到了引用错误。有人能告诉我_user是什么意思吗？

    'use strict'

let assert = require('chai').assert
let request = require('supertest-as-promised')

let app = require('../../app')
let email = 'integration_test_' + Math.floor(Date.now() / 1000) + '@wartech.ua'
let password = 'test'
let name = 'My name'

describe('Authentication Controller', () => {

  it('should register a new user and return token', () => {
    let _token = null;

    return request(app)
      .post('/api/register')
      .send({ email, password, name })
      .expect(201)
      .then((data) => {
        _token = data.body.token;
        assert.ok(_token);
      });
  });

  it('should login existing User', () => {
    let _token = null;
    return request(app)
      .post('/api/login')
      .send({ email, password })
      .expect(200)
      .then((data) => {
        _token = data.body.token;
        assert.ok(_token);
      });
  });

  it('should return an error bad request if email is used', () => {
    return request(app)
      .post('/api/register')
      .send({ email, password, name})
      .expect(400);
  });

  it('should return an error bad request if email isn\'t specified', () => {
    return request(app)
      .post('/api/register')
      .send({ password, name })
      .expect(400);
  });

  it('should return an error bad request if password isn\'t specified', () => {
    return request(app)
      .post('/api/register')
      .send({ email, name })
      .expect(400);
  });
});

describe('Profile controller', () => {

  let _token = null;

  before(() => {
    return request(app)
      .post('/api/login')
      .send({ email, password })
      .then((data) => {
        _token = data.body.token;
        assert.ok(_token);
      });
  });

  it('should fetch the profile info of existing user', () => {
    return request(app)
      .get('/api/profile')
      .set('Authorization', 'Bearer ' + _token)
      .expect(200)
      .then((data) => {
        assert.equal(data.body.email, _user);
      });
  });

  it('should return an error when token is not specified', () => {
    return request(app)
      .get('/api/profile')
      .expect(401);
  });
});

顺便说一下，我的app.js看起来是这样的：

'use strict';
//require packages
let express = require('express');
let app = express();
let bodyParser = require('body-parser');
let morgan = require('morgan');
let mongoose = require('mongoose');
let jwt = require('jsonwebtoken');
let config = require('./config');
let User = require('./models/user');
let router = express.Router();
//connect database
mongoose.connect(config.database);
app.set('superSecret', config.secret);
//configure express
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.use(morgan('dev'));
app.use('/api', router);

//index route
app.get('/', function(req, res) {
    res.send('Hello');
});
//user create route
router.post('/register', function(req, res) {

    //search if user with this email exists
    User.findOne({ email: req.body.email }, function(err, user) {
        if (err) {
            console.log(err);
        } else if (user) {
            //provide status response if true
            res.status(400).json({
                success: false,
                message: 'User with this email already exists'
            });
        } else {
            //if email isn't provided - response with status code 400
            if (!req.body.email) {
                res.status(400).json({
                    success: false,
                    message: 'Email wasn\'t provided'
                })
            } else {
                //if everything is ok create user and save
                User.create({
                    email: req.body.email,
                    password: req.body.password,
                    name: req.body.name
                }, function(err, newUser) {
                    if (err) {
                        console.log(err);
                    } else {
                        // create a token
                        let token = jwt.sign(newUser, app.get('superSecret'), {
                            expiresIn: "24h", // expires in 24 hours
                            issuer: newUser.name
                        });
                        // return the information including token as JSON
                        res.status(201).json({
                            success: true,
                            message: 'Register successful, token sent',
                            token: token
                        });
                    }
                });
            }
        }
    });
});

router.post('/login', function(req, res) {

    // find the user
    User.findOne({
        email: req.body.email
    }, function(err, user) {

        if (err) throw err;

        if (!user) {
            res.json({ success: false, message: 'Authentication failed. User not found.' });
        } else if (user) {

            // check if password matches
            if (user.password != req.body.password) {
                res.json({ success: false, message: 'Authentication failed. Wrong password.' });
            } else if (!req.body.email) {
                //check if email provided
                res.json({ success: false, message: 'Authentication failed. No email was provided. ' });
            } else if (!req.body.email == user.email) {
                //check if email matches
                res.json({ success: false, message: 'Authentication failed. E-mail doesn\'t match. ' });
            }

            // if user is found and password is right
            // create a token
            let token = jwt.sign(user, app.get('superSecret'), {
                expiresIn: "24h" // expires in 24 hours
            });

            // return the information including token as JSON
            res.json({
                success: true,
                message: 'Enjoy your token!',
                token: token
            });
        }



    });
});
router.get('/profile', checkToken, function(req, res) {
    res.json({
        name: req.decoded._doc.name,
        email: req.decoded._doc.email
    })
});

function checkToken(req, res, next) {
    console.log(req.headers['authorization']);
    var token = req.body.token || req.query.token || req.headers['authorization'];

    // decode token
    if (token) {

        // verifies secret and checks exp
        jwt.verify(token, app.get('superSecret'), function(err, decoded) {
            if (err) {
                return res.json({ success: false, message: 'Failed to authenticate token.' });
            } else {
                // if everything is good, save to request for use in other routes
                req.decoded = decoded;
                next();
            }
        });

    } else {
        console.log('token not found');

        // if there is no token
        // return an error
        return res.status(401).send({
            success: false,
            message: 'No token provided.'
        });

    }

}

app.listen(3000, function() {
    console.log('Server started');
});

module.exports = app;

我仍然在试图弄清楚为什么上次的测试给了我一个未经授权的错误401。在将x访问令牌切换到授权之后，我开始获得参考错误。该死的伙计们，我做了大部分的工作，最后被塞进去了。有什么建议吗？

Answer 1

_user是一个未在代码中定义的变量。它用于与data.body.email进行比较，使用assert.equal()，后者内部使用比较运算符==。

当凭证不满足时发生401 unauthorized错误，请检查jwt令牌过期和用户名、密码

因为_user还没有在代码中定义，所以它给出了undefined

您可以将其定义为与上面相同的测试用例。

案例1.

const _user = "your email for login" // email provided while login

it('should fetch the profile info of existing user', () => {
    return request(app)
        .get('/api/profile')
        .set('Authorization', 'Bearer ' + _token)
        .expect(200)
        .then((data) => { // success
            // if data.body.email matches to _user test will pass
            console.log(`email from profile: ${data.body.email} mine user: ${_user}`);
            assert.equal(data.body.email, _user);
        });
});

或者在成功登录之后，这个测试用例可以是这样的，正如assert比较data.body.email一样，您必须使用登录测试用例时使用的测试email。

案例2.

it('should fetch the profile info of existing user', () => {
    return request(app)
        .get('/api/profile')
        .set('Authorization', 'Bearer ' + _token)
        .expect(200)
        .then((data) => {
         assert.equal(data.body.email, email);
        });
});