Merge pull request SpinlockLabs#84 from DirectMyFile/refactor_tests_to_mockito

Pacane · web-flow · commit 974122b70fcb · 2016-10-12T12:01:13.000-04:00
Refactor tests to mockito
diff --git a/pubspec.yaml b/pubspec.yaml
@@ -13,5 +13,5 @@ dependencies:
   markdown: '^0.11.1'
 dev_dependencies:
   browser: '^0.10.0+2'
-  mock: '^0.12.0'
   test: '^0.12.0'
+  mockito: '^1.0.1'
diff --git a/test/git_test.dart b/test/git_test.dart
@@ -6,33 +6,29 @@ import 'dart:convert' show JSON;
 import 'package:github/src/common.dart';
 import 'package:github/src/util.dart';
 import "package:http/http.dart" as http;
-import 'package:mock/mock.dart';
+import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';
 
-import 'helper.dart';
-
-class MockGitHub extends MockWithNamedArgs implements GitHub {}
+class MockGitHub extends Mock implements GitHub {}
 
 void main() {
   MockGitHub github;
   GitService git;
   RepositorySlug repo;
+  var someSha = 'someSHA';
 
   setUp(() {
     github = new MockGitHub();
     git = new GitService(github);
     repo = new RepositorySlug('o', 'n');
   });
 
-  //
-  // BLOB
-  //
   group('getBlob()', () {
     test('constructs correct path', () {
       git.getBlob(repo, 'sh');
-      github
-          .getLogs(callsTo('getJSON', '/repos/o/n/git/blobs/sh'))
-          .verify(happenedOnce);
+
+      verify(github.getJSON('/repos/o/n/git/blobs/sh',
+          convert: GitBlob.fromJSON, statusCode: StatusCodes.OK));
     });
   });
 
@@ -41,33 +37,28 @@ void main() {
       CreateGitBlob blob = new CreateGitBlob('bbb', 'utf-8');
       git.createBlob(repo, blob);
 
-      github
-          .getLogs(callsTo('postJSON', '/repos/o/n/git/blobs'))
-          .verify(happenedOnce);
+      verify(github.postJSON('/repos/o/n/git/blobs',
+          convert: GitBlob.fromJSON,
+          statusCode: StatusCodes.CREATED,
+          body: blob.toJSON()));
     });
 
     test('creates valid JSON body', () {
       CreateGitBlob blob = new CreateGitBlob('bbb', 'utf-8');
-      git.createBlob(repo, blob);
-
-      LogEntryNamedArgs entry = github.getLogs().first;
-      Map body = JSON.decode(entry.namedArgs[#body]);
 
+      git.createBlob(repo, blob);
+      var body = captureSentBody(github);
       expect(body['content'], equals('bbb'));
       expect(body['encoding'], equals('utf-8'));
     });
   });
 
-  //
-  // COMMIT
-  //
   group('getCommit()', () {
     test('constructs correct path', () {
       git.getCommit(repo, 'sh');
 
-      github
-          .getLogs(callsTo('getJSON', '/repos/o/n/git/commits/sh'))
-          .verify(happenedOnce);
+      verify(github.getJSON('/repos/o/n/git/commits/sh',
+          convert: GitCommit.fromJSON, statusCode: StatusCodes.OK));
     });
   });
 
@@ -76,9 +67,10 @@ void main() {
       CreateGitCommit commit = new CreateGitCommit('aMessage', 'aTreeSha');
       git.createCommit(repo, commit);
 
-      github
-          .getLogs(callsTo('postJSON', '/repos/o/n/git/commits'))
-          .verify(happenedOnce);
+      verify(github.postJSON('/repos/o/n/git/commits',
+          convert: GitCommit.fromJSON,
+          statusCode: StatusCodes.CREATED,
+          body: commit.toJSON()));
     });
 
     test('creates valid JSON body', () {
@@ -94,9 +86,7 @@ void main() {
       git.createCommit(repo, commit);
 
       // then
-      LogEntryNamedArgs entry = github.getLogs().first;
-      Map body = JSON.decode(entry.namedArgs[#body]);
-
+      var body = captureSentBody(github);
       expect(body['message'], equals('aMessage'));
       expect(body['tree'], equals('aTreeSha'));
       expect(body['parents'], equals(['parentSha1', 'parentSha2']));
@@ -109,73 +99,71 @@ void main() {
     });
   });
 
-  //
-  // REFERENCE
-  //
   group('getReference()', () {
     test('constructs correct path', () {
       git.getReference(repo, 'heads/b');
 
-      github
-          .getLogs(callsTo('getJSON', '/repos/o/n/git/refs/heads/b'))
-          .verify(happenedOnce);
+      verify(github.getJSON('/repos/o/n/git/refs/heads/b',
+          convert: GitReference.fromJSON, statusCode: StatusCodes.OK));
     });
   });
 
   group('createReference()', () {
+    var someRef = 'refs/heads/b';
     test('constructs correct path', () {
-      git.createReference(repo, 'refs/heads/b', 'someSHA');
+      git.createReference(repo, someRef, someSha);
 
-      github
-          .getLogs(callsTo('postJSON', '/repos/o/n/git/refs'))
-          .verify(happenedOnce);
+      verify(github.postJSON('/repos/o/n/git/refs',
+          convert: GitReference.fromJSON,
+          statusCode: StatusCodes.CREATED,
+          body: JSON.encode({'ref': someRef, 'sha': someSha})));
     });
 
     test('creates valid JSON body', () {
-      git.createReference(repo, 'refs/heads/b', 'someSHA');
-
-      // then
-      LogEntryNamedArgs entry = github.getLogs().first;
-      Map body = JSON.decode(entry.namedArgs[#body]);
+      git.createReference(repo, someRef, someSha);
 
-      expect(body['ref'], equals('refs/heads/b'));
-      expect(body['sha'], equals('someSHA'));
+      var body = captureSentBody(github);
+      expect(body['ref'], equals(someRef));
+      expect(body['sha'], equals(someSha));
     });
   });
 
   group('editReference()', () {
     test('constructs correct path', () {
       // given
-      http.Response res = new http.Response('{}', 200);
-      github
-          .when(callsTo('request', anything, anything))
-          .alwaysReturn(new Future.value(res));
+      http.Response expectedResponse = new http.Response('{}', 200);
+
+      when(github.request(any, any,
+              body: any, headers: typed(any, named: 'headers')))
+          .thenReturn(new Future.value(expectedResponse));
 
       // when
-      git.editReference(repo, 'heads/b', 'someSHA');
+      git.editReference(repo, 'heads/b', someSha);
 
       // then
-      github
-          .getLogs(callsTo('request', 'PATCH', '/repos/o/n/git/refs/heads/b'))
-          .verify(happenedOnce);
+      verify(github.request('PATCH', '/repos/o/n/git/refs/heads/b',
+          headers: typed(any, named: 'headers'), body: any));
     });
 
     test('creates valid JSON body', () {
       // given
-      http.Response res = new http.Response('{}', 200);
-      github
-          .when(callsTo('request', anything, anything))
-          .alwaysReturn(new Future.value(res));
+      http.Response expectedResponse = new http.Response('{}', 200);
+      when(github.request(any, any,
+              body: any, headers: typed(any, named: 'headers')))
+          .thenReturn(new Future.value(expectedResponse));
 
       // when
-      git.editReference(repo, 'heads/b', 'someSHA', force: true);
+      git.editReference(repo, 'heads/b', someSha, force: true);
 
       // then
-      LogEntryNamedArgs entry = github.getLogs().first;
-      Map body = JSON.decode(entry.namedArgs[#body]);
-      Map headers = entry.namedArgs[#headers];
+      var captured = verify(github.request(any, any,
+              body: captureAny, headers: typed(captureAny, named: 'headers')))
+          .captured;
 
-      expect(body['sha'], equals('someSHA'));
+      var body = JSON.decode(captured[0]);
+      var headers = captured[1];
+
+      expect(body['sha'], equals(someSha));
       expect(body['force'], equals(true));
       expect(headers['content-length'], equals('30'));
     });
@@ -184,96 +172,79 @@ void main() {
   group('deleteReference()', () {
     test('constructs correct path', () {
       // given
-      http.Response res = new http.Response('{}', 200);
-      github
-          .when(callsTo('request', anything, anything))
-          .alwaysReturn(new Future.value(res));
+      http.Response expectedResponse = new http.Response('{}', 200);
+      when(github.request(any, any))
+          .thenReturn(new Future.value(expectedResponse));
 
       // when
       git.deleteReference(repo, 'heads/b');
 
       // then
-      github
-          .getLogs(callsTo('request', 'DELETE', '/repos/o/n/git/refs/heads/b'))
-          .verify(happenedOnce);
+      verify(github.request('DELETE', '/repos/o/n/git/refs/heads/b'));
     });
   });
 
-  //
-  // TAG
-  //
   group('getTag()', () {
     test('constructs correct path', () {
-      git.getTag(repo, 'someSHA');
+      git.getTag(repo, someSha);
 
-      github
-          .getLogs(callsTo('getJSON', '/repos/o/n/git/tags/someSHA'))
-          .verify(happenedOnce);
+      verify(github.getJSON('/repos/o/n/git/tags/someSHA',
+          convert: GitTag.fromJSON, statusCode: StatusCodes.OK));
     });
   });
 
   group('createTag()', () {
+    var createGitTag = new CreateGitTag('v0.0.1', 'a message', someSha,
+        'commit', new GitCommitUser('aName', 'aEmail', new DateTime.now()));
+
     test('constructs correct path', () {
-      git.createTag(
-          repo,
-          new CreateGitTag('v0.0.1', 'a message', 'someSHA', 'commit',
-              new GitCommitUser('aName', 'aEmail', new DateTime.now())));
-
-      github
-          .getLogs(callsTo('postJSON', '/repos/o/n/git/tags'))
-          .verify(happenedOnce);
+      git.createTag(repo, createGitTag);
+
+      verify(github.postJSON('/repos/o/n/git/tags',
+          convert: GitTag.fromJSON,
+          statusCode: StatusCodes.CREATED,
+          body: createGitTag.toJSON()));
     });
 
     test('creates valid JSON body', () {
-      git.createTag(
-          repo,
-          new CreateGitTag('v0.0.1', 'a message', 'someSHA', 'commit',
-              new GitCommitUser('aName', 'aEmail', new DateTime.now())));
-
-      LogEntryNamedArgs entry = github.getLogs().first;
-      Map body = JSON.decode(entry.namedArgs[#body]);
+      git.createTag(repo, createGitTag);
 
+      var body = captureSentBody(github);
       expect(body['tag'], equals('v0.0.1'));
       expect(body['message'], equals('a message'));
-      expect(body['object'], equals('someSHA'));
+      expect(body['object'], equals(someSha));
       expect(body['type'], equals('commit'));
       expect(body['tagger']['name'], equals('aName'));
     });
   });
 
-  //
-  // TREE
-  //
-  //
-  // TREE
-  //
   group('getTree()', () {
     test('constructs correct path', () {
       git.getTree(repo, 'sh');
 
-      github
-          .getLogs(callsTo('getJSON', '/repos/o/n/git/trees/sh'))
-          .verify(happenedOnce);
+      verify(github.getJSON('/repos/o/n/git/trees/sh',
+          convert: GitTree.fromJSON, statusCode: StatusCodes.OK));
     });
   });
 
   group('getTree(recursive: true)', () {
     test('constructs correct path', () {
       git.getTree(repo, 'sh', recursive: true);
 
-      github
-          .getLogs(callsTo('getJSON', '/repos/o/n/git/trees/sh?recursive=1'))
-          .verify(happenedOnce);
+      verify(github.getJSON('/repos/o/n/git/trees/sh?recursive=1',
+          convert: GitTree.fromJSON, statusCode: StatusCodes.OK));
     });
   });
 
   group('createTree()', () {
     test('constructs correct path', () {
-      git.createTree(repo, new CreateGitTree([]));
+      var createGitTree = new CreateGitTree([]);
+      git.createTree(repo, createGitTree);
 
-      github
-          .getLogs(callsTo('postJSON', '/repos/o/n/git/trees'))
-          .verify(happenedOnce);
+      verify(github.postJSON('/repos/o/n/git/trees',
+          convert: GitTree.fromJSON,
+          statusCode: StatusCodes.CREATED,
+          body: createGitTree.toJSON()));
     });
 
     test('with sha creates valid JSON body', () {
@@ -287,9 +258,7 @@ void main() {
       git.createTree(repo, tree);
 
       // then
-      LogEntryNamedArgs entry = github.getLogs().first;
-      Map body = JSON.decode(entry.namedArgs[#body]);
-
+      var body = captureSentBody(github);
       expect(body['tree'], isNotNull);
       expect(body['tree'][0]['path'], equals('file.rb'));
       expect(body['tree'][0]['mode'], equals('100644'));
@@ -310,9 +279,7 @@ void main() {
       git.createTree(repo, tree);
 
       // then
-      LogEntryNamedArgs entry = github.getLogs().first;
-      Map body = JSON.decode(entry.namedArgs[#body]);
-
+      var body = captureSentBody(github);
       expect(body['tree'], isNotNull);
       expect(body['tree'][0]['path'], equals('file.rb'));
       expect(body['tree'][0]['mode'], equals('100644'));
@@ -322,3 +289,13 @@ void main() {
     });
   });
 }
+
+Map<String, dynamic> captureSentBody(MockGitHub github) {
+  var bodyString = verify(
+          github.postJSON(any, convert: any, statusCode: any, body: captureAny))
+      .captured
+      .single;
+
+  var body = JSON.decode(bodyString) as Map<String, dynamic>;
+  return body;
+}
diff --git a/test/helper.dart b/test/helper.dart
@@ -6,13 +6,11 @@ import 'dart:io';
 
 import "package:http/http.dart" as http;
 import 'package:github/server.dart';
-import 'package:mock/mock.dart';
 import 'package:test/test.dart';
 
 part 'helper/assets.dart';
 part 'helper/expect.dart';
 part 'helper/http.dart';
-part 'helper/mock.dart';
 
 GitHub github = _makeGitHubClient();
 
diff --git a/test/helper/mock.dart b/test/helper/mock.dart
