<p>sinon.restore() &amp;&amp; sandbox.restore() नकली बहाल नहीं कर रहा है</p>

वैसे भी, यह एक बग जैसा दिखता है, लेकिन सच कहूं तो, मैं इस बारे में पूरी तरह से निश्चित नहीं हूं। मुझे याद है कि नकली पर एक महत्वपूर्ण बिंदु यह है कि उन्हें कुछ अर्थों में अपरिवर्तनीय माना जाता था, लेकिन चूंकि उनके पास राज्य है (यानी वे जानते हैं कि उन्हें बुलाया गया है), कि अपरिवर्तनीयता केवल ठूंठदार व्यवहार तक ही सीमित होनी चाहिए, मुझे लगता है।

@mrodrick इसका उत्तर देने के लिए सही व्यक्ति हो सकता है ...

यदि यह सही व्यवहार है, तो हमें कम से कम डॉक्स को अपडेट करना चाहिए।

@fatso83 बहुत सराहना की! .restore दस्तावेज़ में नकली का उल्लेख किया गया है:

यहाँ से ।

इस बग से बस थोड़ा सा ही था, इसलिए इसे ठीक करना अच्छा होगा।

अगर अगले कुछ दिनों में कोई और इसके लिए पीआर नहीं करता है, तो मैं देख सकता हूं कि मुझे इसे ठीक करने के लिए समय मिल सकता है या नहीं

मैंने अब इस पर ध्यान दिया और डॉक्स थोड़े भ्रामक हैं, जैसा कि ऊपर दिया गया परीक्षण है। ऐसा लगता है कि यह वास्तव में (लगभग) क्या कहता है, लेकिन आइए पहले कुछ शर्तों को परिभाषित करें:

पुनर्स्थापित करें - सैंडबॉक्स को पुनर्स्थापित करने का अर्थ है सभी स्टब किए गए कार्यों को उनकी मूल स्थिति में पुनर्स्थापित करना, जिसका अर्थ है कि प्रत्येक ऑब्जेक्ट से स्टब्स हटा दिए जाते हैं यदि वे मूल को ओवरराइट करते हैं।
रीसेट - रीसेट करने का मतलब है कि बनाए गए प्रत्येक नकली की स्थिति साफ हो गई है, लेकिन वे अभी भी वस्तुओं पर मौजूद हैं।

उपरोक्त परीक्षण के साथ समस्या यह है कि यह

1. सैंडबॉक्स से सभी नकली हटा देता है
2. फिर सैंडबॉक्स (अब खाली) में नकली के संग्रह के माध्यम से जाने के लिए आगे बढ़ता है और नकली की (खाली) सूची को रीसेट करने का प्रयास करता है

इसका कोई मतलब नहीं है :-)

मैंने परीक्षण किया है और reset और restore कॉल उसी तरह काम करते हैं जैसे उन्हें करना चाहिए। लगभग ... reset calledOnce की स्थिति को साफ करता है, लेकिन lastArgument को साफ नहीं किया जा रहा है। यह देखने के लिए थोड़ा और जांचना कि क्या मैंने कुछ विवरण खो दिया है।

इसे प्रतिलिपि प्रस्तुत करने योग्य नहीं के रूप में बंद करना, लेकिन fake.lastArg बग पर एक नया अंक खोलना।

सत्यापित करने के लिए: https://runkit.com/fatso83/sinon-issue-2065

मैं पुष्टि कर सकता हूं कि यह बग मेरे साथ भी हो रहा है, मेरे पास एक परीक्षण परिदृश्य है जिसके लिए कार्यान्वयन को बरकरार रखने की आवश्यकता है, लेकिन फ़ंक्शन पिछले परीक्षण से स्टब परिणाम रखता है, जिसका अर्थ है कि sandbox.restore() वह नहीं कर रहा है जो करने का इरादा है।

यह मेरे साथ संस्करण 7.5.0

@ oscarr-reyes क्या आप देख सकते हैं कि https://github.com/sinonjs/sinon/commit/54df7f7000a9db2dd05319daa49518f3cd5a5dd7 इसे आपके लिए ठीक करता है या नहीं? मुझे लगता है कि इसने इसे अभी तक एक नई रिलीज़ में नहीं बनाया है।

@ oscarr-reyes क्या आप एक प्रतिलिपि प्रस्तुत करने योग्य उदाहरण बनाने में सक्षम हैं? हमने अभी तक वास्तव में इस बग को नहीं देखा है। यदि आप ऊपर दिए गए धागे और मेरी व्याख्या को देखते हैं, तो आप देखेंगे कि हमें केवल एक ही बग मिला है जो एक ध्वज को साफ नहीं किया गया था। बाकी सब काम करता है। इसलिए जब तक हम वास्तव में कुछ प्रमाण नहीं देखते हैं, तब तक कोई बग नहीं है (lastArg ध्वज के अलावा)।

मुझे एक ही मुद्दे का सामना करना पड़ रहा है।

मैं अपने "ValidateCaptcha" मिडलवेयर को सैंडबॉक्सिंग कर रहा हूं और जब मैं इसे पुनर्स्थापित करता हूं तो यह स्टब जारी करना जारी रखता है।

/src/middlewares/captcha.js

const request = require("got");

const validateCaptcha = async (req, res, next) => {
    // if (process.env.NODE_ENV !== "production") return next();

    const captcha = req.body["g-recaptcha-response"] || req.body.g_recaptcha_response;

    // g-recaptcha-response is the key that browser will generate upon form submit.
    // if its blank or null means user has not selected the captcha, so return the error.
    if (captcha === undefined || captcha === "" || captcha === null)
        return res
            .status(400)
            .json({ message: "Please, verify that you are not a robot" });

    // Put your secret key here.
    const secretKey = process.env.GOOGLE_CAPTCHA_API_SECRET_KEY;

    // req.connection.remoteAddress will provide IP address of connected user.
    const verificationUrl = `https://www.google.com/recaptcha/api/siteverify?secret=${secretKey}&response=${captcha}`;

    try {

        // Hitting GET request to the URL, Google will respond with success or error scenario.
        const { body } = await request.post(verificationUrl, { responseType: "json" });

        // Success will be true or false depending upon captcha validation.
        if (body.success !== undefined && !body.success)
            return res
                .status(400)
                .json({ message: "Captcha validation error" });
    } catch (error) {
        return res
            .status(503)
            .json({ message: "Couldn't validate captcha" });
    }

    next();
};

module.exports = {
    validateCaptcha,
};

/test/api/user.spec.js

require("../setup.spec");
const supertest = require("supertest");
const captcha = require("../../src/middlewares/captcha");
const sinon = require("sinon");
let app;
let agent;
let sandbox;

const login = (anAgent, userCredentials) =>
    anAgent
        .post("/api/users/signIn")
        .send(userCredentials);

const logout = (anAgent) =>
    anAgent
        .post("/api/users/signOut");

describe("User endpoints", function () {
    this.beforeAll(async () => {
        sandbox = sinon.createSandbox();
        sandbox
            .stub(captcha, "validateCaptcha")
            .callsFake(async (req, res, next) => {
                console.log("Validate Captcha FAKE");
                return next();
            });
        // sandbox.restore();
    });

    this.beforeEach(async () => {
        app = require("../../src/app");
        agent = supertest.agent(app);
        const sequelize = require("../../src/models");
        await sequelize.sync({ force: true });

        const Customer = require("../../src/models/customer");
        const User = require("../../src/models/user");
        await Customer.create(
            {
                firstName: "Test",
                lastName: "Customer",
                user: {
                    email: "[email protected]",
                    password: "boo",
                },
            },
            {
                include: [User],
            }
        );
    });

    this.afterEach(async () => {
        sandbox.restore();
    });

    it("should create a new user", function (done) {
        agent
            .post("/api/users/signUp")
            .send({
                firstName: "firstName",
                lastName: "lastName",
                email: "[email protected]",
                password: "aPassword",
            })
            .expect(201)
            .end((err, res) => {
                err ? done(err) : done();
            });
    });

    it("should sign in", function (done) {
        login(agent, { email: "[email protected]", password: "boo" })
            .expect(200)
            .end((err, res) => {
                const { message, user } = res.body;
                message.should.be.equal("valid");
                user.should.have.property("email").equal("[email protected]");
                user.should.have.property("customer").have.property("firstName").equal("Test");
                user.should.have.property("customer").have.property("lastName").equal("Customer");

                agent
                    .get("/api/users/me")
                    .expect(200)
                    .end((err, res) => {
                        const user = res.body;
                        user.should.have.property("email").equal("[email protected]");
                        user.should.have.property("customer").have.property("firstName").equal("Test");
                        user.should.have.property("customer").have.property("lastName").equal("Customer");
                        err ? done(err) : done();
                    });
            });
    });

    it("should sign out", async function () {
        await login(agent, { email: "[email protected]", password: "boo" });
        await logout(agent)
            .expect(302)
            .expect("Location", "/");

        return agent
            .get("/api/users/me")
            .expect(401);
    });

    it("should return unauthorized", function (done) {
        agent
            .get("/api/users/me")
            .expect(401)
            .end((err, res) => {
                err ? done(err) : done();
            });
    });
});

मैं यह जांचने के लिए क्या कर रहा हूं कि यह काम नहीं करता है:
1) पहले टेस्ट के लिए इसका मॉक करें
2) इसे निम्नलिखित के लिए पुनर्स्थापित करें

पहले सभी के अंदर एक टिप्पणी है "sandbox.restore ();" कि मैंने कोशिश की है और वहाँ यह काम किया... लेकिन यह बेकार है

मैं भी अपने app.js . के लिए हर बार आवश्यकता कर रहा हूँ

पांच मिनट पहले मैंने इसे संशोधित किया है:

require("../setup.spec");
const decache = require("decache");
const supertest = require("supertest");
const sequelize = require("../../src/models");

const sinon = require("sinon");
const sandbox = sinon.createSandbox();
let agent;

const login = (anAgent, userCredentials) =>
    anAgent
        .post("/api/users/signIn")
        .send(userCredentials);

const logout = (anAgent) =>
    anAgent
        .post("/api/users/signOut");

describe("User endpoints", function () {
    this.beforeAll(async () => {

    });

    this.beforeEach(async () => {
        decache("../../src/app");
        decache("../../src/middlewares/captcha");

        const captcha = require("../../src/middlewares/captcha");

        sandbox
            .stub(captcha, "validateCaptcha")
            .callsFake(async (req, res, next) => {
                console.log("Validate Captcha FAKE");
                return next();
            });

        const app = require("../../src/app");
        agent = supertest.agent(app);
        await sequelize.sync({ force: true });


        const Customer = require("../../src/models/customer");
        const User = require("../../src/models/user");
        await Customer.create(
            {
                firstName: "Test",
                lastName: "Customer",
                user: {
                    email: "[email protected]",
                    password: "boo",
                },
            },
            {
                include: [User],
            }
        );
    });

    this.afterEach(async () => {
        sandbox.restore();
    });

    it("should create a new user", function (done) {
        agent
            .post("/api/users/signUp")
            .send({
                firstName: "firstName",
                lastName: "lastName",
                email: "[email protected]",
                password: "aPassword",
            })
            .expect(201)
            .end((err, res) => {
                err ? done(err) : done();
            });
    });

    it("should sign in", function (done) {
        login(agent, { email: "[email protected]", password: "boo" })
            .expect(200)
            .end((err, res) => {
                const { message, user } = res.body;
                message.should.be.equal("valid");
                user.should.have.property("email").equal("[email protected]");
                user.should.have.property("customer").have.property("firstName").equal("Test");
                user.should.have.property("customer").have.property("lastName").equal("Customer");

                agent
                    .get("/api/users/me")
                    .expect(200)
                    .end((err, res) => {
                        const user = res.body;
                        user.should.have.property("email").equal("[email protected]");
                        user.should.have.property("customer").have.property("firstName").equal("Test");
                        user.should.have.property("customer").have.property("lastName").equal("Customer");
                        err ? done(err) : done();
                    });
            });
    });

    it("should sign out", async function () {
        await login(agent, { email: "[email protected]", password: "boo" });
        await logout(agent)
            .expect(302)
            .expect("Location", "/");

        return agent
            .get("/api/users/me")
            .expect(401);
    });

    it("should return unauthorized", function (done) {
        agent
            .get("/api/users/me")
            .expect(401)
            .end((err, res) => {
                err ? done(err) : done();
            });
    });
});

मैं भी इस मुद्दे को देख रहा हूं। यह बंद क्यों है?

यह हो सकता है कि पुनर्स्थापना का व्यवहार स्टब को सेट करने के लिए उपयोग किए जाने वाले विशिष्ट सिंटैक्स के प्रति संवेदनशील हो। अफैक ये दोनों _चाहिए_ ऐसा करने के वैध तरीके हैं लेकिन पुनर्स्थापना() अलग है। एक में यह काम करता है और दूसरे में इसके अप्रत्याशित परिणाम होते हैं।

const sinon = require('sinon')

// restore does not work as expected

let db = {
  query: () => {
    return 'my query 1'
  }
}
const dbStub = sinon.stub().resolves('somejson')
db.query = dbStub
db.query() // somejson
sinon.restore()
db.query() // resolves nothing

// restore works as expected

db = {
  query: () => {
    return 'my query 1'
  }
}
sinon.stub(db, 'query').resolves('somejson')
db.query() // somejson
sinon.restore()
db.query() //my query 1

@scottpatrickwright जब आप सीधे db.query असाइनमेंट करते हैं, तो sinon को यह जानने का कोई तरीका नहीं है कि क्या पुनर्स्थापित करने की आवश्यकता है या असाइनमेंट से पहले मूल्य क्या था।

@scottpatrickwright यह बंद है क्योंकि कोई बग नहीं है, जैसा कि धागे से स्पष्ट होना चाहिए। यह सिर्फ उपयोगकर्ता त्रुटि थी, जैसा कि आपके मामले में है: यह वर्णित और इच्छित के रूप में काम करता है :-)

सिनॉन सैंडबॉक्स उन चीजों को साफ कर सकता है जिनके बारे में वह जानता है। इसका मतलब है कि सिनॉन को उन वस्तुओं का ज्ञान होना चाहिए जिनके साथ वह बातचीत करता है। आपके द्वारा ऊपर वर्णित ठूंठ को स्टैंडअलोन बनाया गया है। सिनॉन को आपके द्वारा असाइन की गई किसी भी वस्तु से अवगत नहीं कराया जाता है। वह दूसरे उदाहरण में बदल जाता है। आप इसे हासिल करने के लिए sinon.replace(obj, fieldname, fake) भी कर सकते हैं। यह सिर्फ जावास्क्रिप्ट है

काफी उचित - स्पष्टीकरण के लिए धन्यवाद।

शुक्र, 19 फरवरी, 2021 को सुबह 7:02 बजे कार्ल-एरिक कोप्सेंग नोटिफिकेशन @github.com
लिखा था:

@scottpatrickwright https://github.com/scottpatrickwright यह बंद है
क्योंकि कोई बग नहीं है, जैसा कि धागे से स्पष्ट होना चाहिए। यह बस गया था
उपयोगकर्ता त्रुटि, जैसा कि आपके मामले में है: यह वर्णित और इच्छित के रूप में काम करता है :-)

सिनॉन सैंडबॉक्स उन चीजों को साफ कर सकता है जिनके बारे में वह जानता है। इसका मतलब है कि सिनोन है
उन वस्तुओं का ज्ञान प्राप्त करना जिनके साथ यह बातचीत करता है ठूंठ आप
ऊपर वर्णित स्टैंडअलोन बनाया गया है। सिनॉन को इनमें से किसी के बारे में अवगत नहीं कराया गया है
जिन वस्तुओं को आप इसे असाइन करते हैं। वह दूसरे उदाहरण में बदल जाता है। आप ऐसा कर सकते हैं
इसे प्राप्त करने के लिए sinon.replace(obj, fieldname, fake) भी करें। यह सिर्फ
जावास्क्रिप्ट

-
आप इसे प्राप्त कर रहे हैं क्योंकि आपका उल्लेख किया गया था।
इस ईमेल का सीधे उत्तर दें, इसे GitHub पर देखें
https://github.com/sinonjs/sinon/issues/2065#issuecomment-782032440 , या
सदस्यता समाप्त
https://github.com/notifications/unsubscribe-auth/AAKKRTFVMGEYVIB5GSIDXKTS7ZHMRANCNFSM4IGBASQQ
.