Adding greater than functionality to criteria, validation

src/Criteria/AverageResponseTime.ts

@@ -1,8 +1,23 @@
 export class AverageResponseTime {
 
     lessThanTime: number;
+    greaterThanTime: number;
 
     lessThan(time) {
+        if (this.greaterThanTime > time) {
+            throw new Error('Cannot set lessThan less than greaterThan');
+        }
+
         this.lessThanTime = time;
+        return this;
+    }
+
+    greaterThan(time) {
+        if (this.lessThanTime < time) {
+            throw new Error('Cannot set greaterThan greater than lessThan');
+        }
+
+        this.greaterThanTime = time;
+        return this;
     }
 }

src/Criteria/Criteria.ts

@@ -3,13 +3,34 @@ import {BuildBreakerError} from '../BuildBreakerError';
 
 export class Criteria {
     averageResponseTimeObject;
+    predicateFunction;
 
     averageResponseTime() {
         this.averageResponseTimeObject = new AverageResponseTime();
         return this.averageResponseTimeObject;
     }
 
+    predicate(func: (SummaryResults) => boolean) {
+        this.predicateFunction = func;
+    }
+
     validate(results) {
-        throw new BuildBreakerError('Average response time was greater than 50 ms, failing the build', results);
+        if (this.averageResponseTimeObject) {
+            if (this.averageResponseTimeObject.lessThanTime < results.averageResponseTime()) {
+                throw new BuildBreakerError('Average response time was greater than '
+                    + this.averageResponseTimeObject.lessThanTime + ' ms, failing the build', results);
+            }
+
+            if (this.averageResponseTimeObject.greaterThanTime > results.averageResponseTime()) {
+                throw new BuildBreakerError('Average response time was less than '
+                    + this.averageResponseTimeObject.greaterThanTime + ' ms, failing the build', results);
+            }
+        }
+
+        if (this.predicateFunction) {
+            if (this.predicateFunction(results)) {
+                throw new BuildBreakerError('Predicate evaluated to false', results);
+            }
+        }
     }
 }

src/Criteria/__test__/TestCriteria.ts

@@ -0,0 +1,66 @@
+import assert = require('power-assert');
+
+import {Criteria} from '../Criteria';
+import {SummaryResults} from '../../Results/SummaryResults';
+import {HttpRequestRecord} from '../../Steps/Http/HttpRequestRecord';
+import {HttpGetStep} from '../../Steps/Http/HttpGetStep';
+
+describe('Criteria', () => {
+    function getResultsWithAverageResponseTimeOf(averageResponseTime) {
+        let summaryResults = new SummaryResults(null);
+        let httpRequestRecord = new HttpRequestRecord(new HttpGetStep(null, null, null, null), {
+            body: null,
+            rawBody: null,
+            statusCode: 200
+        }, averageResponseTime, Date.now());
+        summaryResults.requests.push(httpRequestRecord);
+        return summaryResults;
+    }
+
+    describe('Average Response time', () => {
+        describe('greaterThan', () => {
+            it('should allow a greaterThan to be specified', () => {
+                let criteria = new Criteria();
+                criteria.averageResponseTime()
+                    .greaterThan(50);
+
+                let summaryResults = getResultsWithAverageResponseTimeOf(75);
+
+                criteria.validate(summaryResults);
+            });
+
+            it('should fail if the average response time is less than the greaterThan', () => {
+                let criteria = new Criteria();
+                criteria.averageResponseTime()
+                    .greaterThan(50);
+
+                let summaryResults = getResultsWithAverageResponseTimeOf(25);
+
+                try {
+                    criteria.validate(summaryResults);
+                    assert.ok(false);
+                } catch (e) {
+                    assert.ok('Average response time was less tahn 50 ms, failing the build', e.message);
+                }
+            });
+
+            it('should immediately error if a lessThan is set lower than the greaterThan', () => {
+                try {
+                    new Criteria().averageResponseTime().greaterThan(100).lessThan(50);
+                    assert.ok(false);
+                } catch (e) {
+                    assert.equal('Cannot set lessThan less than greaterThan', e.message);
+                }
+            });
+
+            it('should immediately error if a greaterThan is set greater than the lessThan', () => {
+                try {
+                    new Criteria().averageResponseTime().lessThan(150).greaterThan(200);
+                    assert.ok(false);
+                } catch (e) {
+                    assert.equal('Cannot set greaterThan greater than lessThan', e.message);
+                }
+            });
+        });
+    });
+});

src/__test__/TestTurbulance.ts

@@ -998,6 +998,74 @@ types.map((type) => {
                         assert.equal(1, error.results.requests.length);
                     });
             });
+
+            it('should specify what the target criteria was', () => {
+                http.whenGet(URL_1).thenReturn(new HttpResponse({
+                    key: 'value'
+                })).delayResponse(100);
+
+                return turbulence
+                    .startUserSteps()
+                    .get(URL_1)
+                    .breaker((criteria) => {
+                        criteria
+                            .averageResponseTime()
+                            .lessThan(75);
+                    })
+                    .endUserSteps()
+                    .run()
+                    .then(() => {
+                        assert.ok(false); // Fail the promise regardless so we hit our assertion in the catch block
+                    })
+                    .catch((error) => {
+                        assert.equal('Average response time was greater than 75 ms, failing the build', error.message);
+                        assert.equal(1, error.results.requests.length);
+                    });
+            });
+
+            it('should not fail the build if the criteria are met', () => {
+                http.whenGet(URL_1).thenReturn(new HttpResponse({
+                    key: 'value'
+                })).delayResponse(100);
+
+                return turbulence
+                    .startUserSteps()
+                    .get(URL_1)
+                    .breaker((criteria) => {
+                        criteria
+                            .averageResponseTime()
+                            .lessThan(150);
+                    })
+                    .endUserSteps()
+                    .run()
+                    .then((results) => {
+                        assert.equal(1, results.requests.length);
+                    });
+            });
+
+            it('should allow artbitrary functions to be used', () => {
+                http.whenGet(URL_1).thenReturn(new HttpResponse({
+                    key: 'value'
+                })).delayResponse(100);
+
+                return turbulence
+                    .startUserSteps()
+                    .get(URL_1)
+                    .breaker((criteria) => {
+                        criteria.predicate((results) => {
+                            return results.requests.length === 1;
+                        });
+                    })
+                    .endUserSteps()
+                    .run()
+                    .then(() => {
+                        assert.ok(false); // Fail the promise regardless so we hit our assertion in the catch block
+                    })
+                    .catch((error) => {
+                        assert.equal('Predicate evaluated to false', error.message);
+                        assert.equal(1, error.results.requests.length);
+                    });
+            });
         });
 
         xdescribe('Distributed Testing', () => {