dynamic skip -- works in some places...

[shaunc]

Thanks very much for dynamic skip!

It works well for me like this:

describe "foo", ->
   beforeEach ->
       @skip()
    it "should foo", ->

However, it doesn't work if the "beforeEach is in a wrapping suite:

describe "foo", ->
   beforeEach ->
       @skip()
    describe "bar", ->
        it "should foo", ->

Also doesn't seem to work in "before".

[danielstjules]

Thanks for mentioning it! We've been discussing this bug in #1618 (comment) as well.

[boneskull]

@danielstjules should this be closed?

[danielstjules]

@boneskull no, sorry for the confusion - that's my bad. It's a separate issue from #1604 The PR I brought up gives us the ability to use this.skip() from an async spec/hook. However, the PR also brought up the fact that the existing synchronous skip behavior, on which its based, has a bug.

For another example, see #1618 (comment) The result of that test suite should probably be 2 pending specs.

[shaunc]

pace #1618 -- my tests look sync, but they are using promises, so actually async. in "before" I do some db setup, which I need to have done before I can decide on skip(), so wrapping for delayed definition becomes cumbersome. I could put the whole module inside setupDB.then( ... ), but this is not ideal -- dynamic skip is a great feature for me. :)

[danielstjules]

Ah I see - using skip() from async logic isn't supported at the moment, but if #1618 is merged, that might change!

[dmarcelino]

+1 for async skip!

[ScottFreeCode]

Also doesn't seem to work in "before".

Reviewing this issue since some of the other async skip issues have since been fixed; I expanded the test cases to cover all combinations like so:

test.coffee

describe "beforeEach", ->
    describe "outer", ->
        beforeEach ->
            @skip()
        it "should be skipped", ->

    describe "outer", ->
        beforeEach ->
            @skip()
        describe "inner", ->
            it "should be skipped", ->

    describe "outer", ->
        beforeEach ->
            @skip()
        it "should be skipped", ->
        describe "inner", ->
            it "should be skipped", ->

describe "before", ->
    describe "outer", ->
        before ->
            @skip()
        it "should be skipped", ->

    describe "outer", ->
        before ->
            @skip()
        describe "inner", ->
            it "should be skipped", ->

    describe "outer", ->
        before ->
            @skip()
        it "should be skipped", ->
        describe "inner", ->
            it "should be skipped", ->

(And, just to be on the safe side:)

test.js

describe("beforeEach", function() {
    describe("outer", function() {
        beforeEach(function() {
            this.skip()
        })
        it("should be skipped", function() {})
    })

    describe("outer", function() {
        beforeEach(function() {
            this.skip()
        })
        describe("inner", function() {
            it("should be skipped", function() {})
        })
    })

    describe("outer", function() {
        beforeEach(function() {
            this.skip()
        })
        it("should be skipped", function() {})
        describe("inner", function() {
            it("should be skipped", function() {})
        })
    })
})

describe("before", function() {
    describe("outer", function() {
        before(function() {
            this.skip()
        })
        it("should be skipped", function() {})
    })

    describe("outer", function() {
        before(function() {
            this.skip()
        })
        describe("inner", function() {
            it("should be skipped", function() {})
        })
    })

    describe("outer", function() {
        before(function() {
            this.skip()
        })
        it("should be skipped", function() {})
        describe("inner", function() {
            it("should be skipped", function() {})
        })
    })
})

Both output:

 beforeEach
   outer
     - should be skipped
   outer
     inner
       - should be skipped
   outer
     - should be skipped
     inner
       - should be skipped

 before
   outer
     - should be skipped
   outer
     inner
       √ should be skipped
   outer
     - should be skipped
     inner
       √ should be skipped


 2 passing (62ms)
 6 pending

@mochajs/core Is it expected that this.skip in before hooks would not apply to nested suites? I'm not entirely clear whether #2571 covers that.

[stale]

I am a bot that watches issues for inactivity.
This issue hasn't had any recent activity, and I'm labeling it stale. In 14 days, if there are no further comments or activity, I will close this issue.
Thanks for contributing to Mocha!

[boneskull]

let's try to consolidate the open issues around the skip behavior.

[juergba]

 beforeEach
    outer
      - should be skipped
    outer
      inner
        - should be skipped
    outer
      - should be skipped
      inner
        - should be skipped

  before
    outer
      - should be skipped
    outer
      inner
        - should be skipped
    outer
      - should be skipped
      inner
        - should be skipped

  0 passing (19ms)
  8 pending

With current master this.skip applies consistently to nested suites for both before and beforeEach hooks.