vanessa-behavior 0.4.4

data/features/wire_protocol.feature

@@ -0,0 +1,337 @@
+@[ИмяФичи]=wire_protocol;\features
+
+
+Feature: Wire Protocol
+  In order to be allow Cucumber to touch my app in intimate places
+  As a developer on platform which doesn't support Ruby
+  I want a low-level protocol which Cucumber can use to run steps within my app
+
+  #
+  # Cucumber's wire protocol is an implementation of Cucumber's internal
+  # 'programming language' abstraction, and allows step definitions to be
+  # implemented and invoked on any platform.
+  #
+  # Communication is over a TCP socket, which Cucumber connects to when it finds
+  # a definition file with the .wire extension in the step_definitions folder
+  # (or other load path).  Note that these files are rendered with ERB when loaded.
+  #
+  # Cucumber sends the following request messages out over the wire:
+  #
+  #   * step_matches   : this is used to find out whether the wire server has a
+  #                      definition for a given step
+  #   * invoke         : this is used to ask for a step definition to be invoked
+  #   * begin_scenario : signals that cucumber is about to execute a scenario
+  #   * end_scenario   : signals that cucumber has finished executing a scenario
+  #   * snippet_text   : requests a snippet for an undefined step
+  #
+  # Every message supports two standard responses:
+  #   * success        : which expects different arguments (sometimes none at
+  #                      all) depending on the request.
+  #   * fail           : causes a Cucumber::WireSupport::WireException to be
+  #                      raised.
+  #
+  # Some messages support more responses - see below for details.
+  #
+  # A WirePacket flowing in either direction is formatted as a JSON-encoded
+  # string, with a newline character signaling the end of a packet. See the
+  # specs for Cucumber::WireSupport::WirePacket for more details.
+  #
+  # These messages are described in detail below, with examples.
+  #
+
+  Background:
+    Given a file named 'features/wired.feature' with:
+      """
+      Feature: High strung
+        Scenario: Wired
+          Given we're all wired
+
+      """
+    And a file named 'features/step_definitions/some_remote_place.wire' with:
+      """
+      host: localhost
+      port: 54321
+
+      """
+
+
+  #
+  # # Request: 'step_matches'
+  #
+  # When the features have been parsed, Cucumber will send a step_matches
+  # message to ask the wire server if it can match a step name. This happens for
+  # each of the steps in each of the features.
+  #
+  # The wire server replies with an array of StepMatch objects.
+
+  Scenario: Dry run finds no step match
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response       |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[]] |
+    When I run 'cucumber --dry-run --no-snippets -f progress'
+    And it should pass with:
+      """
+      U
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+
+      """
+
+  # When each StepMatch is returned, it contains the following data:
+  #   * id   - identifier for the step definition to be used later when if it
+  #            needs to be invoked. The identifier can be any string value and
+  #            is simply used for the wire server's own reference.
+  #   * args - any argument values as captured by the wire end's own regular
+  #            expression (or other argument matching) process.
+  Scenario: Dry run finds a step match
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                            |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
+    When I run 'cucumber --dry-run -f progress'
+    And it should pass with:
+      """
+      -
+
+      1 scenario (1 skipped)
+      1 step (1 skipped)
+
+      """
+
+  # Optionally, the StepMatch can also contain a source reference, and a native
+  # regexp string which will be used by some formatters.
+  Scenario: Step matches returns details about the remote step definition
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                                                                           |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[], "source":"MyApp.MyClass:123", "regexp":"we.*"}]] |
+    When I run 'cucumber -f stepdefs --dry-run'
+    Then it should pass with:
+      """
+      -
+
+      we.*   # MyApp.MyClass:123
+
+      1 scenario (1 skipped)
+      1 step (1 skipped)
+
+      """
+    And the stderr should not contain anything
+
+
+  #
+  # # Request: 'invoke'
+  #
+  # Assuming a StepMatch was returned for a given step name, when it's time to
+  # invoke that step definition, Cucumber will send an invoke message.
+  #
+  # The invoke message contains the ID of the step definition, as returned by
+  # the wire server in response to the the step_matches call, along with the
+  # arguments that were parsed from the step name during the same step_matches
+  # call.
+  #
+  # The wire server will normally[1] reply one of the following:
+  #   * success
+  #   * fail
+  #   * pending : optionally takes a message argument
+  #
+  # [1] This isn't the whole story: see also wire_protocol_table_diffing.feature
+  #
+
+  # ## Pending Steps
+  #
+  Scenario: Invoke a step definition which is pending
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                            |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
+      | ["begin_scenario"]                                   | ["success"]                         |
+      | ["invoke",{"id":"1","args":[]}]                      | ["pending", "I'll do it later"]     |
+      | ["end_scenario"]                                     | ["success"]                         |
+    When I run 'cucumber -f pretty -q'
+    And it should pass with:
+      """
+      Feature: High strung
+
+        Scenario: Wired
+          Given we're all wired
+            I'll do it later (Cucumber::Pending)
+            features/wired.feature:3:in 'Given we're all wired'
+
+      1 scenario (1 pending)
+      1 step (1 pending)
+
+      """
+
+  # ## Passing Steps
+  #
+  Scenario: Invoke a step definition which passes
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                            |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
+      | ["begin_scenario"]                                   | ["success"]                         |
+      | ["invoke",{"id":"1","args":[]}]                      | ["success"]                         |
+      | ["end_scenario"]                                     | ["success"]                         |
+    When I run 'cucumber -f progress'
+    And it should pass with:
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  # ## Failing Steps
+  #
+  # When an invoked step definition fails, it can return details of the exception
+  # in the reply to invoke. This causes a Cucumber::WireSupport::WireException to be
+  # raised.
+  #
+  # Valid arguments are:
+  #   * message (mandatory)
+  #   * exception
+  #   * backtrace
+  #
+  # See the specs for Cucumber::WireSupport::WireException for more details
+  #
+  Scenario: Invoke a step definition which fails
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                                                                            |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]]                                                 |
+      | ["begin_scenario"]                                   | ["success"]                                                                         |
+      | ["invoke",{"id":"1","args":[]}]                      | ["fail",{"message":"The wires are down", "exception":"Some.Foreign.ExceptionType"}] |
+      | ["end_scenario"]                                     | ["success"]                                                                         |
+    When I run 'cucumber -f progress'
+    Then the stderr should not contain anything
+    And it should fail with:
+      """
+      F
+
+      (::) failed steps (::)
+
+      The wires are down (Some.Foreign.ExceptionType from localhost:54321)
+      features/wired.feature:3:in 'Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:2 # Scenario: Wired
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """
+
+  # ## Step Arguments
+  #
+  # Imagine we have a step definition like:
+  #
+  #     Given /we're all (.*)/ do | what_we_are |
+  #     end
+  #
+  # When this step definition matches the step name in our feature, the word
+  # 'wired' will be captured as an argument.
+  #
+  # Cucumber expects this StepArgument to be returned in the StepMatch. The keys
+  # have the following meanings:
+  #   * val : the value of the string captured for that argument from the step
+  #           name passed in step_matches
+  #   * pos : the position within the step name that the argument was matched
+  #           (used for formatter highlighting)
+  #
+  Scenario: Invoke a step definition which takes string arguments (and passes)
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                                                     |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[{"val":"wired", "pos":10}]}]] |
+      | ["begin_scenario"]                                   | ["success"]                                                  |
+      | ["invoke",{"id":"1","args":["wired"]}]               | ["success"]                                                  |
+      | ["end_scenario"]                                     | ["success"]                                                  |
+    When I run 'cucumber -f progress'
+    Then the stderr should not contain anything
+    And it should pass with:
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  # ## Multiline Table Arguments
+  #
+  # When the step has a multiline table argument, it will be passed with the
+  # invoke message as a string - a serialized JSON array of array of strings.
+  # In the following scenario our step definition takes two arguments - one
+  # captures the "we're" and the other takes the table.
+  Scenario: Invoke a step definition which takes table arguments (and passes)
+    Given a file named 'features/wired_on_tables.feature' with:
+      """
+      Feature: High strung
+        Scenario: Wired and more
+          Given we're all:
+            | wired |
+            | high  |
+            | happy |
+      """
+    And there is a wire server running on port 54321 which understands the following protocol:
+      | request                                                               | response                                                    |
+      | ["step_matches",{"name_to_match":"we're all:"}]                       | ["success",[{"id":"1", "args":[{"val":"we're", "pos":0}]}]] |
+      | ["begin_scenario"]                                                    | ["success"]                                                 |
+      | ["invoke",{"id":"1","args":["we're",[["wired"],["high"],["happy"]]]}] | ["success"]                                                 |
+      | ["end_scenario"]                                                      | ["success"]                                                 |
+    When I run 'cucumber -f progress features/wired_on_tables.feature'
+    Then the stderr should not contain anything
+    And it should pass with:
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+
+  #
+  # # Request: 'snippets'
+  #
+  Scenario: Wire server returns snippets for a step that didn't match
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                                                                          | response                         |
+      | ["step_matches",{"name_to_match":"we're all wired"}]                                             | ["success",[]]                   |
+      | ["snippet_text",{"step_keyword":"Given","multiline_arg_class":"","step_name":"we're all wired"}] | ["success","foo()\n  bar;\nbaz"] |
+      | ["begin_scenario"]                                                                               | ["success"]                      |
+      | ["end_scenario"]                                                                                 | ["success"]                      |
+    When I run 'cucumber -f pretty'
+    Then the stderr should not contain anything
+    And it should pass with:
+      """
+      Feature: High strung
+
+        Scenario: Wired         # features/wired.feature:2
+          Given we're all wired # features/wired.feature:3
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+      """
+    And the output should contain:
+      """
+
+      You can implement step definitions for undefined steps with these snippets:
+
+      foo()
+        bar;
+      baz
+
+      """
+
+  #
+  # # Bad Response
+  #
+  Scenario: Unexpected response
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                            |
+      | ["begin_scenario"]                                   | ["yikes"]                           |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["success",[{"id":"1", "args":[]}]] |
+    When I run 'cucumber -f pretty'
+    Then the stdout should contain:
+      """
+      undefined method 'handle_yikes'
+      """
+

data/lib/TemplateEpf/renames.txt

@@ -0,0 +1,7 @@
+79a499cc-1782-4a2f-abe7-61ea4d49fd5a-->und\79a499cc-1782-4a2f-abe7-61ea4d49fd5a
+8aa13ab8-188a-4f59-be4f-031aa5450c90.0\info-->und\8aa13ab8-188a-4f59-be4f-031aa5450c90.0\info
+8aa13ab8-188a-4f59-be4f-031aa5450c90.0\text-->ObjectModule.txt
+copyinfo-->und\copyinfo
+root-->und\root
+version-->und\version
+versions-->und\versions

data/lib/TemplateEpf/und/79a499cc-1782-4a2f-abe7-61ea4d49fd5a

@@ -0,0 +1,37 @@
+{1,
+{79a499cc-1782-4a2f-abe7-61ea4d49fd5a},1,
+{c3831ec8-d8d5-4f93-8a22-f9bfae07327f,
+{1,
+{4,1fa267af-3d54-4f70-ac00-718486d7aafd,ed829681-4496-44fd-adeb-667f09d931c3,
+{0,
+{0,
+{0,0,8aa13ab8-188a-4f59-be4f-031aa5450c90},"TemplateEpf",
+{1,"ru","Template epf"},""}
+},00000000-0000-0000-0000-000000000000,"",00000000-0000-0000-0000-000000000000},4,
+{2bcef0d1-0981-11d6-b9b8-0050bae0a95d,0},
+{3daea016-69b7-4ed4-9453-127911372fe6,0},
+{d5b0e5ed-256d-401c-9c36-f630cafd8a62,0},
+{ec6bb5e5-b7a8-4d75-bec9-658107a699cf,1,
+{
+{0,
+{25,
+{2,
+{0,
+{0,0,03f1a2cc-5646-4a21-a16d-f6863c782a20},"Контекст",
+{1,"ru","Контекст"},""},
+{"Pattern"}
+},0,
+{0},
+{0},0,"",0,
+{"U"},
+{"U"},0,00000000-0000-0000-0000-000000000000,2,0,
+{5004,0},
+{3,0,0},
+{0,0},0,
+{0},
+{"S",""},0}
+},0}
+}
+}
+}
+}

data/lib/TemplateEpf/und/7a39ab7a-5023-41fd-ae4c-8d0e903c5cba.0/info

@@ -0,0 +1 @@
+{3,1,0,"",0}

data/lib/TemplateEpf/und/8aa13ab8-188a-4f59-be4f-031aa5450c90.0/info

@@ -0,0 +1 @@
+{3,1,0,"",0}

data/lib/TemplateEpf/und/copyinfo

@@ -0,0 +1,7 @@
+{4,
+{0},
+{0},
+{0},
+{0,0},
+{0}
+}

data/lib/TemplateEpf/und/d4666efc-32c5-4cbe-a642-505988996654

@@ -0,0 +1,17 @@
+{1,
+{d4666efc-32c5-4cbe-a642-505988996654},1,
+{c3831ec8-d8d5-4f93-8a22-f9bfae07327f,
+{1,
+{4,5bf81622-16aa-4645-a1d8-509874887e57,f517432b-a7f6-4263-93df-fe0fdadf5791,
+{0,
+{0,
+{0,0,7a39ab7a-5023-41fd-ae4c-8d0e903c5cba},"TemplateEpf",
+{1,"ru","TemplateEpf"},""}
+},00000000-0000-0000-0000-000000000000,"",00000000-0000-0000-0000-000000000000},4,
+{2bcef0d1-0981-11d6-b9b8-0050bae0a95d,0},
+{3daea016-69b7-4ed4-9453-127911372fe6,0},
+{d5b0e5ed-256d-401c-9c36-f630cafd8a62,0},
+{ec6bb5e5-b7a8-4d75-bec9-658107a699cf,0}
+}
+}
+}

data/lib/TemplateEpf/und/root

@@ -0,0 +1 @@
+{2,79a499cc-1782-4a2f-abe7-61ea4d49fd5a,}

data/lib/TemplateEpf/und/version

@@ -0,0 +1,3 @@
+{
+{216,0}
+}

data/lib/TemplateEpf/und/versions

@@ -0,0 +1 @@
+{1,7,"",957ec74c-a1dc-4a1f-a270-c36c0f9f4a04,"8aa13ab8-188a-4f59-be4f-031aa5450c90.0",19f79066-4b2c-4d0d-831e-732c45f6209a,"root",2c064e3e-498c-4a6a-849b-b6d3887cbc3f,"79a499cc-1782-4a2f-abe7-61ea4d49fd5a",2b64eb12-7485-488d-8ba0-80b8dc3a912e,"copyinfo",9d1835f3-6ec1-4d6d-ae08-4115907229fc,"versions",c2df9ea6-94a4-40de-88ee-0063bfcff47d,"version",9fb14ed9-b9b2-4b46-bd4b-8ec1ec984ab1}

data/tasks/developers.start.cmd

@@ -0,0 +1,13 @@
+@echo off
+
+@echo sync and update precommit1c hook
+
+cd .\..\vendor\precommit1c\
+
+xcopy .\ibService .\..\..\.git\hooks\ibService\ /Y /E /F
+xcopy .\pre-commit .\..\..\.git\hooks\ /Y /F
+xcopy .\v8Reader .\..\..\.git\hooks\v8Reader\ /Y /F
+xcopy .\pyv8unpack.py .\..\..\.git\hooks\ /Y /F
+
+cd .\..\..\
+git config --local core.quotepath false