pact-consumer-js-dsl - npm Package Compare versions

Comparing version 0.2.0 to 0.2.1

bower.json

 {
   "name": "pact-consumer-js-dsl",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "ignore": [
@@ -5,0 +5,0 @@ ".gitignore",

CHANGELOG.md

@@ -7,2 +7,6 @@ # Changelog
 
+### 0.2.1 (28 Sep 2015)
+
+* 5794963 - Add eachLike array flexible matcher (Michael Isgro, Fri Sep 4 15:07:15 2015 +1000)
+
 ### 0.2 (7 Sep 2015)
@@ -9,0 +13,0 @@

dist/pact-consumer-js-dsl.js

@@ -160,3 +160,3 @@ (function(root, factory) {
 
-    if (!opts || typeof(opts.port) === 'undefined' ) {
+    if (!opts || typeof opts.port === 'undefined' ) {
       throw new Error('Error creating MockService. Please provide the Pact mock service port');
@@ -170,3 +170,3 @@ }
 
-    if (typeof(opts.done) !== 'function') {
+    if (typeof opts.done !== 'function') {
       throw new Error('Error creating MockService. Please provide an option called "done", that is a function that asserts (using your test framework of choice) that the first argument, error, is null.');
@@ -266,4 +266,5 @@ }
     this.term = function(term) {
-
-        if (!term || typeof(term.generate) === 'undefined' || typeof(term.matcher) === 'undefined' ) {
+        if (!term ||
+            typeof term.generate === 'undefined' ||
+            typeof term.matcher === 'undefined') {
             throw new Error('Error creating a Pact Term. Please provide an object containing \'generate\' and \'matcher\' properties');
@@ -285,8 +286,24 @@ }
 
-    this.somethingLike = function(value) {
+    this.eachLike = function(content, options) {
+        if(typeof content === 'undefined') {
+            throw new Error('Error creating a Pact eachLike. Please provide a content argument');
+        }
 
-        if (typeof(value) === 'undefined' || typeof(value) === 'function') {
-            throw new Error('Error creating a Pact SomethingLike Match. Value cannot be a function or undefined');
+        if(options && !options.min) {
+            throw new Error('Error creating a Pact eachLike. Please provide options.min that is > 1');
         }
+        
+        return {
+            'json_class': 'Pact::ArrayLike',
+            'contents': content,
+            'min': (!options) ? 1 : options.min
+        };
+    } ;
 
+    this.somethingLike = function(value) {
+        if (typeof value === 'undefined' ||
+            typeof value === 'function') {
+            throw new Error('Error creating a Pact somethingLike Match. Value cannot be a function or undefined');
+        }
+
         return {
@@ -293,0 +310,0 @@ 'json_class': 'Pact::SomethingLike',

example/web/client-spec.js

@@ -64,5 +64,5 @@ (function() {
             body: {
-              friends: [{
+              friends: Pact.Match.eachLike({
                 name: Pact.Match.somethingLike('Sue') // Doesn't tie the Provider to a particular friend such as 'Sue'
-              }]
+              }, {min: 1})
             }
@@ -69,0 +69,0 @@ });

gulpfile.js

@@ -150,2 +150,6 @@ 'use strict';
 
+gulp.task('run-integration-tests', function(callback){
+    runSequence('run-browser-tests-pact2', 'run-browser-tests', callback);
+});
+
 gulp.task('run-tests', function(callback){
@@ -152,0 +156,0 @@ runSequence('run-unit-tests', 'run-browser-tests', 'run-browser-tests-pact2', 'run-node-tests', callback);

package.json

 {
   "name": "pact-consumer-js-dsl",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "DSL to write pact tests in Javascript",
@@ -48,3 +48,4 @@ "main": "dist/pact-consumer-js-dsl.js",
     "test": "gulp run-tests",
-    "unit-test": "gulp run-unit-tests"
+    "unit-test": "gulp run-unit-tests",
+    "integration-test": "gulp run-integration-tests"
   },
@@ -51,0 +52,0 @@ "repository": {

README.md

@@ -5,4 +5,6 @@ # Pact Consumer Javascript DSL
 
-This codebase provides a Javascript DSL for creating pacts. If you are new to Pact, please read the Pact [README](pact-readme) first.
+This codebase provides a Javascript DSL for creating pacts. If you are new to Pact, please read the Pact [README][pact-readme] first.
 
+The Javascript DSL is compatible with v2 of the [pact-specification](https://github.com/bethesque/pact-specification/tree/version-2) and supports type based matching, flexible array lengths, and regular expressions (read more below).
+
 This DSL relies on the Ruby [pact-mock_service][pact-mock-service] gem to provide the mock service for the Javascript tests. If you do not want to use Ruby in your project, please read about using a standalone Pact mock service [here][pact-mock-service-without-ruby].
@@ -133,3 +135,3 @@
 
-   * Start the pact mock server with `bundle exec pact-mock-service -p 1234 -l log/pact.logs --pact-dir tmp/pacts`
+   * Start the pact mock server with `bundle exec pact-mock-service -p 1234 --pact-specification-version 2.0.0 -l log/pact.logs --pact-dir tmp/pacts`
    * Run `karma start` (in another terminal window)
@@ -142,7 +144,5 @@ * Inspect the pact file that has been written to "hello_consumer-hello_provider.json"
 
-*Note*: The following will only work with verifications done by the Ruby Pact library, because it uses a Ruby specific way of serialising the data structure.
-
 #### Match by regular expression
 
-Remember that the mock service is written in Ruby, so the regular expression must be in a Ruby format, not a Javascript format.
+Remember that the mock service is written in Ruby, so the regular expression must be in a Ruby format, not a Javascript format. Make sure to start the mock service with the argument `--pact-specification-version 2.0.0`.
 
@@ -203,2 +203,45 @@ ```javascript
 
+#### Match based on arrays
+
+Matching provides the ability to specify flexible length arrays. For example:
+
+```javascript
+Pact.Match.eachLike(obj, { min: 3 })
+```
+
+Where `obj` can be any javascript object, value or Pact.Match. It takes optional argument (`{ min: 3 }`) where min is greater than 0 and defaults to 1 if not provided. 
+
+Below is an example that uses all of the Pact Matchers.
+
+```javascript
+
+var somethingLike = Pact.Match.somethingLike;
+var term = Pact.Match.term;
+var eachLike = Pact.Match.eachLike;
+
+provider
+  .given('there is a product')
+  .uponReceiving("request for products")
+  .withRequest({
+    method: "get",
+    path: "/products",
+    query: {
+      category: "clothing"
+    }
+  })
+  .willRespondWith({
+    status: 200,
+    headers: {
+        'Content-Type': 'application/json'
+    },
+    body: {
+        "items":eachLike({
+            size: somethingLike(10),
+            colour: term("red|green|blue", {generates: "blue"}),
+            tag: eachLike(somethingLike("jumper"))
+        }, {min: 2})
+    }
+  });
+```
+
 ### Examples
@@ -205,0 +248,0 @@

spec/integration/v2/mock_service_spec.js

@@ -7,2 +7,3 @@ 'use strict';
   beforeEach(function() {
+
     doneCallback = jasmine.createSpy('doneCallback').and.callFake(function (error) {
@@ -23,2 +24,3 @@ expect(error).toBe(null);
     describe("with an argument list", function() {
+
         var doHttpCall = function(callback) {
@@ -25,0 +27,0 @@ specHelper.makeRequest({

spec/unit/match_spec.js

 'use strict';
 
-describe('Match', function () {
-    describe('term', function () {
-        describe('when provided a term', function () {
-            it('should return a serialized Ruby object', function () {
+describe('Match', function() {
+
+    //create alias
+    var somethingLike = Pact.Match.somethingLike;
+    var term = Pact.Match.term;
+    var eachLike = Pact.Match.eachLike;
+
+
+    describe('term', function() {
+        describe('when provided a term', function() {
+            it('should return a serialized Ruby object', function() {
                 var expected = {
@@ -19,3 +26,3 @@ "json_class": "Pact::Term",
 
-                var term = Pact.Match.term({
+                var match = term({
                     generate: "myawesomeword",
@@ -25,15 +32,15 @@ matcher: "\\w+"
 
-                expect(term).toEqual(expected);
+                expect(match).toEqual(expected);
             });
         });
 
-        describe("when not provided with a valid term", function () {
+        describe("when not provided with a valid term", function() {
             var createTheTerm = function (badArg) {
                 return function () {
-                    Pact.Match.term(badArg);
+                    term(badArg);
                 }
             };
 
-            describe("when no term is provided", function () {
-                it("should throw an Error", function () {
+            describe("when no term is provided", function() {
+                it("should throw an Error", function() {
                     expect(createTheTerm()).toThrow();
@@ -43,3 +50,3 @@ });
 
-            describe("when an invalid term is provided", function () {
+            describe("when an invalid term is provided", function() {
                 it("should throw an Error", function () {
@@ -56,4 +63,4 @@ expect(createTheTerm({})).toThrow();
     describe('somethingLike', function () {
-        describe('when provided a value', function () {
-            it('should return a serialized Ruby object', function () {
+        describe('when provided a value', function() {
+            it('should return a serialized Ruby object', function() {
                 var expected = {
@@ -64,3 +71,3 @@ "json_class": "Pact::SomethingLike",
 
-                var match = Pact.Match.somethingLike("myspecialvalue");
+                var match = somethingLike("myspecialvalue");
                 expect(match).toEqual(expected);
@@ -70,11 +77,11 @@ });
 
-        describe("when not provided with a valid value", function () {
+        describe("when not provided with a valid value", function() {
             var createTheValue = function (badArg) {
                 return function () {
-                    Pact.Match.somethingLike(badArg);
+                    somethingLike(badArg);
                 }
             };
 
-            describe("when no value is provided", function () {
-                it("should throw an Error", function () {
+            describe("when no value is provided", function() {
+                it("should throw an Error", function() {
                     expect(createTheValue()).toThrow();
@@ -84,4 +91,4 @@ });
 
-            describe("when an invalid value is provided", function () {
-                it("should throw an Error", function () {
+            describe("when an invalid value is provided", function() {
+                it("should throw an Error", function() {
                     expect(createTheValue(undefined)).toThrow();
@@ -93,2 +100,221 @@ expect(createTheValue(function(){})).toThrow();
     });
-});
+
+    describe('eachLike', function() {
+        describe('when content is null', function() {
+            it('should provide null as contents', function() {
+                var expected = {
+                    "json_class": "Pact::ArrayLike",
+                    "contents": null,
+                    "min": 1
+                };
+
+                var match = eachLike(null, {min: 1});
+                expect(match).toEqual(expected);
+            });
+        });
+
+        describe('when an object is provided', function() {
+            it('should provide the object as contents', function() {
+                var expected = {
+                    "json_class": "Pact::ArrayLike",
+                    "contents": {a:1},
+                    "min": 1
+                };
+
+                var match = eachLike({a: 1}, {min: 1});
+                expect(match).toEqual(expected);
+            });
+        });
+
+        describe('when object.min is invalid', function() {
+            it('should throw an error message', function() {
+                expect(function() {
+                    eachLike({a: 1}, {min: 0});
+                }).toThrow();
+
+                expect(function() {
+                    eachLike({a: 1}, {min: null});
+                }).toThrow();
+            });
+        });
+
+        describe('when an array is provided', function() {
+            it('should provide the array as contents', function() {
+                var expected = {
+                    "json_class": "Pact::ArrayLike",
+                    "contents": [1,2,3],
+                    "min": 1
+                };
+
+                var match = eachLike([1,2,3], {min: 1});
+                expect(match).toEqual(expected);
+            });
+        });
+
+        describe('when a value is provided', function() {
+            it('should add the value in contents', function() {
+                var expected = {
+                    "json_class": "Pact::ArrayLike",
+                    "contents": "test",
+                    "min": 1
+                };
+
+                var match = eachLike("test", {min: 1});
+                expect(match).toEqual(expected);
+            });
+        });
+
+        describe('when the content has Pact.Macters', function() {
+            describe('of type somethingLike', function() {
+                it('should nest somethingLike correctly', function() {
+                    var expected = {
+                        "json_class": "Pact::ArrayLike",
+                        "contents": {
+                            "id": {
+                                "json_class": "Pact::SomethingLike",
+                                "contents": 10
+                            }
+                        },
+                        "min": 1
+                    };
+
+                    var match = eachLike({ id: somethingLike(10) }, {min: 1});
+                    expect(match).toEqual(expected);
+                });
+            });
+
+            describe('of type term', function() {
+                it('should nest term correctly', function() {
+                    var expected = {
+                        "json_class": "Pact::ArrayLike",
+                        "contents": {
+                            "colour": {
+                                "json_class": "Pact::Term",
+                                "data": {
+                                    "generate": "red",
+                                    "matcher": {
+                                        "json_class": "Regexp",
+                                        "o": 0,
+                                        "s": "red|green"
+                                    }
+                                }
+                            }
+                        },
+                        "min": 1
+                    };
+
+                    var match = eachLike({
+                        colour: term({
+                            generate: 'red',
+                            matcher: 'red|green'
+                        })
+                    }, {min: 1});
+
+                    expect(match).toEqual(expected);
+                });
+            });
+
+            describe('of type eachLike', function() {
+                it('should nest eachlike in contents', function() {
+                    var expected = {
+                        "json_class": "Pact::ArrayLike",
+                        "contents": {
+                            "json_class": "Pact::ArrayLike",
+                            "contents": "blue",
+                            "min": 1
+                        },
+                        "min": 1
+                    };
+
+                    var match = eachLike(eachLike("blue", {min: 1}), {min: 1});
+                    expect(match).toEqual(expected);
+                });
+            });
+
+            describe('complex object with multiple Pact.Matchers', function() {
+                it('should nest objects correctly', function() {
+                    var expected = {
+                        "json_class": "Pact::ArrayLike",
+                        "contents": {
+                            "json_class": "Pact::ArrayLike",
+                            "contents": {
+                                "size": {
+                                    "json_class": "Pact::SomethingLike",
+                                    "contents": 10
+                                },
+                                "colour": {
+                                    "json_class": "Pact::Term",
+                                    "data": {
+                                        "generate": "red",
+                                        "matcher": {
+                                            "json_class": "Regexp",
+                                            "o": 0,
+                                            "s": "red|green|blue"
+                                        }
+                                    }
+                                },
+                                "tag": {
+                                    "json_class": "Pact::ArrayLike",
+                                    "contents": [
+                                        {
+                                            "json_class": "Pact::SomethingLike",
+                                            "contents": "jumper"
+                                        },
+                                        {
+                                            "json_class": "Pact::SomethingLike",
+                                            "contents": "shirt"
+                                        }
+                                    ],
+                                    "min": 2
+                                }
+                            },
+                            "min": 1
+                        },
+                        "min": 1
+                    };
+
+                    var match = eachLike(
+                                    eachLike({
+                                        size: somethingLike(10),
+                                        colour: term({generate: "red", matcher: "red|green|blue"}),
+                                        tag: eachLike([
+                                                somethingLike("jumper"),
+                                                somethingLike("shirt")
+                                            ], {min: 2})
+                                        }, {min: 1}),
+                                    {min: 1});
+
+                    expect(match).toEqual(expected);
+                });
+            });
+        });
+
+        describe('When no options.min is not provided', function() {
+            it('should default to a min of 1', function () {
+                var expected = {
+                    "json_class": "Pact::ArrayLike",
+                    "contents": {a: 1},
+                    "min": 1
+                };
+
+                var match = eachLike({a: 1});
+                expect(match).toEqual(expected);
+            });
+        });
+
+        describe('When a options.min is provided', function() {
+            it('should provide the object as contents', function() {
+                var expected = {
+                    "json_class": "Pact::ArrayLike",
+                    "contents": {a: 1},
+                    "min": 3
+                };
+
+                var match = eachLike({a: 1}, {min: 3});
+                expect(match).toEqual(expected);
+            });
+        });
+
+    });
+
+});

src/match.js

@@ -5,4 +5,5 @@ Pact.Match = Pact.Match || {};
     this.term = function(term) {
-
-        if (!term || typeof(term.generate) === 'undefined' || typeof(term.matcher) === 'undefined' ) {
+        if (!term ||
+            typeof term.generate === 'undefined' ||
+            typeof term.matcher === 'undefined') {
             throw new Error('Error creating a Pact Term. Please provide an object containing \'generate\' and \'matcher\' properties');
@@ -24,8 +25,24 @@ }
 
-    this.somethingLike = function(value) {
+    this.eachLike = function(content, options) {
+        if(typeof content === 'undefined') {
+            throw new Error('Error creating a Pact eachLike. Please provide a content argument');
+        }
 
-        if (typeof(value) === 'undefined' || typeof(value) === 'function') {
-            throw new Error('Error creating a Pact SomethingLike Match. Value cannot be a function or undefined');
+        if(options && !options.min) {
+            throw new Error('Error creating a Pact eachLike. Please provide options.min that is > 1');
         }
+        
+        return {
+            'json_class': 'Pact::ArrayLike',
+            'contents': content,
+            'min': (!options) ? 1 : options.min
+        };
+    } ;
 
+    this.somethingLike = function(value) {
+        if (typeof value === 'undefined' ||
+            typeof value === 'function') {
+            throw new Error('Error creating a Pact somethingLike Match. Value cannot be a function or undefined');
+        }
+
         return {
@@ -32,0 +49,0 @@ 'json_class': 'Pact::SomethingLike',

src/mockService.js

@@ -7,3 +7,3 @@ Pact.MockService = Pact.MockService || {};
 
-    if (!opts || typeof(opts.port) === 'undefined' ) {
+    if (!opts || typeof opts.port === 'undefined' ) {
       throw new Error('Error creating MockService. Please provide the Pact mock service port');
@@ -17,3 +17,3 @@ }
 
-    if (typeof(opts.done) !== 'function') {
+    if (typeof opts.done !== 'function') {
       throw new Error('Error creating MockService. Please provide an option called "done", that is a function that asserts (using your test framework of choice) that the first argument, error, is null.');
@@ -20,0 +20,0 @@ }

No alert changes

Improved metrics

Total package byte prevSize

116004

4.79%

Lines of code

2007

3.67%

Number of lines in readme file

277

18.38%

No dependency changes