dimakura / sspec Goto Github PK

After all we'd better use global functions:

• describe which calls SSMatcher.describe behind the scenes
• context (same as describe)
• it which calls SSMatcher.it behind the scenes
• expect which calls SSMatcher.expect behind the scenes

There are a lot of checks we should be performing in order not to stack in some undesirable state:

1. describe/context can be called only when current session is present
2. it can be called only within describe/context
3. expect can be called only within it

We will need to monitor type of "currentNode" during initialization and report failures when requirements not met.

We should be able to run focused tests.

From tester perspective it looks like:

fdescribe("Focused group")
fcontext("Focused context")
fit("Focused example")

Internally Node should have property focused: Bool = false, which could be turned to true with makeFocused() method.

When we run initialization, we create list of all registered examples. Examples under focused parent are also considered focused.

During test run we skip unfocused examples.

Currently we display all running examples with their titles.

We can make alternative reporter which will display green/yellow/red dots for examples.

We need one "runner" for all test functions:

import XCTest
import SSpec

class BDDTests: XCTestCase {
  func testBDD() {
    SSpec_run {
      myTestFunction1()
      myTestFunction2()
      myTestFunction3()
    }
  }

  static var allTests = [
    ("testBDD", testBDD),
  ]
}

Attempt to run two SSpec_runs should be reported as error.

Session mode has it's own top-level type.

We should be moving it under Session type.

When failed, we need to exit with some error codes.

Try how it works with CIs.

We need to spec:

1. Node and its subclasses
2. Collectors and subclasses

The only place we use Node's level property is spec reporter.

We actually don't need it: level can be calculated in the reporter itself. Or even inferred from parent hierarchy.

We can improve error & example descriptions by supporting bold by inserting it in backquotes: `bold`.

We should be able to add extensions to SSExpect from outside packages:

extension SSExpect where T == MyCustomClas {
  public var beCPU: Void {
    assert(value.isCorrect,        // ERROR: value not visible
           error: "\(valueStr)")   // ERROR: valueStr not visible
  }
}

Also:

• toString not visible.
• negate variable should be accessible too.

Currently there's no error reporting on failures: we just have false flag for the given run.

The mechanism used should be easily extensible.

Globals are still problem.

Let's hide them behind SSpec and if we need global function, do it explicitly:

let describe = SSpec.describe
// ...

Another alternative would be to have "test class":

class MyTestClass: SSpecTest {
  func test1() {
    describe() {
      // ...
    }
  }
}

But it looks too verbose.

context("some context")

is not visible in the output at all.

Should be displayed as "Skipped" (yellow color).

Running SSpec under XCode.

If we try to compare two arrays, it will fail on compile time:

expect([1, 2]).to.eq([1,2])
// error: generic parameter 'T' could not be inferred

We need to fix this and also introduce new matchers for arrays:

• eq -- for exact matching;
• includes -- all elements of the parameter array are included in the matching array;
• same -- both arrays have same elements (possibly with different order).

before function should be run before all examples:

var a = 0

before {
  a = 100
}

it {
  // modifies a
  a = 200
}

it {
  print(a) // prints 100
}

Also we need after function to clean-up data.

We need release script which can:

1. Upgrade the version
2. Ask for "What's new" to append to changes log
3. Push and merge commit on github

There's an issue with SSpec.reporter visibility.

• Current: internal
• Should be: public