How to use the request.jar function in request

it('should not see logout link yet', function(done) {
    // otherwise logins are not remembered in a session
    request.jar();
    return request('http://localhost:7901/', function(err, response, body) {
      assert(!err);
      // Is our status code good?
      assert.equal(response.statusCode, 200);
      // Did we get our page back?
      assert(body.match(/login/));
      assert(!body.match(/logout/));
      return done();
    });

  });

  var loginLogoutJar = request.jar();
  var loginEmailLogoutJar = request.jar();

  it('should be able to login a user', function(done) {
    // otherwise logins are not remembered in a session
    return request.post('http://localhost:7901/login', {
      form: { username: 'HarryPutter', password: 'crookshanks' },
      followAllRedirects: true,
      jar: loginLogoutJar
    }, function(err, response, body) {
      assert(!err);
      // Is our status code good?
      assert.equal(response.statusCode, 200);
      // Did we get our page back?
      assert(body.match(/logout/));
      return done();
    });

Zotero.debug("Trying " + url);
		}
		
		/*let runningInstance;
		if ((runningInstance = Zotero.Server.Translation.waitingForSelection[data.sessionid])
				&& data.items) {
			// Already waiting for a items response, so just pass this there
			runningInstance._cookieSandbox.setTimeout(SERVER_TRANSLATION_TIMEOUT*1000,
				runningInstance.timeout.bind(runningInstance));
			runningInstance.sendResponse = sendResponseCallback;
			runningInstance.selectDone(data.items);
			break;
		}*/
		
		// New request
		this._cookieSandbox = cookieJar();
		
		let resolve;
		let reject;
		let promise = new Promise(function () {
			resolve = arguments[0];
			reject = arguments[1];
		});
		
		let translate = new Translate.Web();
		let translatePromise;
		translate.setHandler("translators", async function (translate, translators) {
			// Force single-page saving
			if (this.options.single) {
				translators = translators.filter(t => t.itemType != 'multiple');
			}

* Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * Provide a couple of useful extensions to request.js for OSLC
 * purposes. One is to handle an authenticaiton challenge on any
 * GET operation. The other is to provide some convenience functions
 * for handling cookies.
 */

var request = require('request');
var cookies = request.jar();
var URI = require('urijs');

/* 
 * Set the typical OSLC defaults
 */
request = request.defaults({
	headers: {
		'Accept': 'application/rdf+xml',  // reliably available RDF representation
		'OSLC-Core-Version': '2.0'
	},
	strictSSL: false,  		  // no need for certificates
	jar: cookies,                // use the cookie jar to save cookies
	followAllRedirects: true  // for FORM based authentication
})
request.cookies = cookies;
request.mode='no-cors';

it('', function (done) {
        request.post(url('/connect/facebook'), {
          jar: request.jar(),
          json: true
        }, function (err, res, body) {
          body.match(/Error: Grant: mount body parser middleware first/)
          done()
        })
      })

next(null, data);
		}

		plugins.registerHook('myTestPlugin', {
			hook: 'filter:register.interstitial',
			method: hookMethod,
		});

		var data = {
			username: 'interstitial',
			password: '123456',
			'password-confirm': '123456',
			email: 'test@me.com',
		};

		var jar = request.jar();
		request({
			url: nconf.get('url') + '/api/config',
			json: true,
			jar: jar,
		}, function (err, response, body) {
			assert.ifError(err);

			request.post(nconf.get('url') + '/register', {
				form: data,
				json: true,
				jar: jar,
				headers: {
					'x-csrf-token': body.csrf_token,
				},
			}, function (err, res, body) {
				assert.ifError(err);

function leads (options, done) {
  var o = options || {};
  var jar = request.jar();

  contra.waterfall([
    function logon (next) {
      var href = 'https://twitter.com/login';
      go(jar, 'GET', href, {}, next);
    },
    function login (res, body, next) {
      var $ = cheerio.load(body);
      var href = 'https://twitter.com/sessions';
      var params = {
        'session[username_or_email]': o.username,
        'session[password]': o.password,
        authenticity_token: secret($, 'authenticity_token'),
        ui_metrics: secret($, 'ui_metrics'),
        ui_metrics_seed: secret($, 'ui_metrics_seed'),
        scribe_log: '',

exports.wrappedLogin = function wrappedLogin(params, next) {
	params.logger.debug('Signing in for auto discovery');
	var requestOptions = _.defaults(params.options.login, {
		jar: request.jar()
	});
	request(requestOptions, function (err, response, body) {
		params.options.handleResponse(err, body, function (err, result) {
			if (err) {
				params.logger.error('Login failed. Please double check your credentials.');
				next(err);
			} else {
				params.options.jar = requestOptions.jar;
				next();
			}
		});
	});
};

function getDomoappsDomain() {
  const uuid = Domo.createUUID();
  const j = request.jar();
  const auth = `SID="${mostRecent.sid}"`;
  const cookie = request.cookie(auth);
  j.setCookie(cookie, `https://${mostRecent.instance}`);
  return new Promise((resolve) => {
    request({
      url: `https://${mostRecent.instance}/api/content/v1/mobile/environment`,
      jar: j
    }, (err, res) => {
      if (res.statusCode === 200) {
        resolve(`https://${uuid}.${JSON.parse(res.body).domoappsDomain}`);
      } else {
        resolve(`https://${uuid}.domoapps.${getEnv()}`);
      }
    });
  });
}

constructor(options) {
    this.wsapiUrl = `${options.server}/slm/webservice/${options.apiVersion}`;
    this.jar = request.jar();
    this._requestOptions = Object.assign({ jar: this.jar }, options.requestOptions);
    this.httpRequest = request.defaults(this._requestOptions);
    this._hasKey = options.requestOptions &&
        options.requestOptions.headers &&
        options.requestOptions.headers.zsessionid;
  }