Drive the Refresher in GitHubTabContainer

Author: smashwilson

lib/containers/github-tab-container.js

@@ -1,9 +1,11 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import yubikiri from 'yubikiri';
+import {CompositeDisposable, Disposable} from 'event-kit';
 
 import {GithubLoginModelPropType, RefHolderPropType} from '../prop-types';
 import OperationStateObserver, {PUSH, PULL, FETCH} from '../models/operation-state-observer';
+import Refresher from '../models/refresher';
 import GitHubTabController from '../controllers/github-tab-controller';
 import ObserveModel from '../views/observe-model';
 import RemoteSet from '../models/remote-set';
@@ -25,19 +27,41 @@ export default class GitHubTabContainer extends React.Component {
     openGitTab: PropTypes.func.isRequired,
   }
 
-  state = {};
+  constructor(props) {
+    super(props);
+
+    this.state = {
+      lastRepository: null,
+      remoteOperationObserver: new Disposable(),
+      refresher: new Refresher(),
+      observerSub: new Disposable(),
+    };
+  }
 
   static getDerivedStateFromProps(props, state) {
     if (props.repository !== state.lastRepository) {
+      state.remoteOperationObserver.dispose();
+      state.observerSub.dispose();
+
+      const remoteOperationObserver = new OperationStateObserver(props.repository, PUSH, PULL, FETCH);
+      const observerSub = remoteOperationObserver.onDidComplete(() => state.refresher.trigger());
+
       return {
         lastRepository: props.repository,
-        remoteOperationObserver: new OperationStateObserver(props.repository, PUSH, PULL, FETCH),
+        remoteOperationObserver,
+        observerSub,
       };
     }
 
     return null;
   }
 
+  componentWillUnmount() {
+    this.state.observerSub.dispose();
+    this.state.remoteOperationObserver.dispose();
+    this.state.refresher.dispose();
+  }
+
   fetchRepositoryData = repository => {
     return yubikiri({
       workingDirectory: repository.getWorkingDirectoryPath(),
@@ -66,6 +90,7 @@ export default class GitHubTabContainer extends React.Component {
       return (
         <GitHubTabController
           {...this.props}
+          refresher={this.state.refresher}
           remoteOperationObserver={this.state.remoteOperationObserver}
 
           allRemotes={new RemoteSet()}
@@ -81,6 +106,7 @@ export default class GitHubTabContainer extends React.Component {
       return (
         <GitHubTabController
           {...this.props}
+          refresher={this.state.refresher}
           remoteOperationObserver={this.state.remoteOperationObserver}
 
           allRemotes={new RemoteSet()}
@@ -96,6 +122,7 @@ export default class GitHubTabContainer extends React.Component {
       <GitHubTabController
         {...data}
         {...this.props}
+        refresher={this.state.refresher}
         remoteOperationObserver={this.state.remoteOperationObserver}
         isLoading={false}
       />

test/containers/github-tab-container.test.js

@@ -1,19 +1,29 @@
 import React from 'react';
-import {mount} from 'enzyme';
+import {mount, shallow} from 'enzyme';
 
-import {cloneRepository} from '../helpers';
+import {buildRepository, cloneRepository} from '../helpers';
 import GitHubTabContainer from '../../lib/containers/github-tab-container';
+import GitHubTabController from '../../lib/controllers/github-tab-controller';
 import Repository from '../../lib/models/repository';
 import {InMemoryStrategy} from '../../lib/shared/keytar-strategy';
 import GithubLoginModel from '../../lib/models/github-login-model';
 import RefHolder from '../../lib/models/ref-holder';
 
 describe('GitHubTabContainer', function() {
-  let atomEnv, repository;
+  let atomEnv, repository, defaultRepositoryData;
 
-  beforeEach(function() {
+  beforeEach(async function() {
     atomEnv = global.buildAtomEnvironment();
-    repository = Repository.absent();
+    repository = await buildRepository(await cloneRepository());
+
+    defaultRepositoryData = {
+      workingDirectory: repository.getWorkingDirectoryPath(),
+      allRemotes: await repository.getRemotes(),
+      branches: await repository.getBranches(),
+      selectedRemoteName: 'origin',
+      aheadCount: 0,
+      pushInProgress: false,
+    };
   });
 
   afterEach(function() {
@@ -41,26 +51,66 @@ describe('GitHubTabContainer', function() {
     );
   }
 
-  describe('operation state observer', function() {
-    it('creates an observer on the current repository', function() {
-      const wrapper = mount(buildApp());
+  describe('refresher', function() {
+    let wrapper, retry;
+
+    function stubRepository(repo) {
+      sinon.stub(repo.getOperationStates(), 'isFetchInProgress').returns(false);
+      sinon.stub(repo.getOperationStates(), 'isPushInProgress').returns(false);
+      sinon.stub(repo.getOperationStates(), 'isPullInProgress').returns(false);
+    }
+
+    function simulateOperation(repo, name, middle = () => {}) {
+      const accessor = `is${name[0].toUpperCase()}${name.slice(1)}InProgress`;
+      const methodStub = repo.getOperationStates()[accessor];
+      methodStub.returns(true);
+      repo.state.didUpdate();
+      middle();
+      methodStub.returns(false);
+      repo.state.didUpdate();
+    }
+
+    beforeEach(function() {
+      wrapper = shallow(buildApp());
+      const childWrapper = wrapper.find('ObserveModel').renderProp('children')(defaultRepositoryData);
+
+      retry = sinon.spy();
+      const refresher = childWrapper.find(GitHubTabController).prop('refresher');
+      refresher.setRetryCallback(Symbol('key'), retry);
+
+      stubRepository(repository);
+    });
+
+    it('triggers a refresh when the current repository completes a fetch, push, or pull', function() {
+      assert.isFalse(retry.called);
+
+      simulateOperation(repository, 'fetch', () => assert.isFalse(retry.called));
+      assert.strictEqual(retry.callCount, 1);
 
-      const observer = wrapper.state('remoteOperationObserver');
-      assert.strictEqual(observer.repository, repository);
+      simulateOperation(repository, 'push', () => assert.strictEqual(retry.callCount, 1));
+      assert.strictEqual(retry.callCount, 2);
 
-      wrapper.setProps({});
-      assert.strictEqual(wrapper.state('remoteOperationObserver'), observer);
+      simulateOperation(repository, 'pull', () => assert.strictEqual(retry.callCount, 2));
+      assert.strictEqual(retry.callCount, 3);
     });
 
-    it('creates a new observer when the repository changes', function() {
-      const repository0 = Repository.absent();
-      const wrapper = mount(buildApp({repository: repository0}));
+    it('un-observes an old repository and observes a new one', async function() {
+      const other = await buildRepository(await cloneRepository());
+      stubRepository(other);
+      wrapper.setProps({repository: other});
+
+      simulateOperation(repository, 'fetch');
+      assert.isFalse(retry.called);
+
+      simulateOperation(other, 'fetch');
+      assert.isTrue(retry.called);
+    });
 
-      const observer0 = wrapper.state('remoteOperationObserver');
+    it('un-observes the repository when unmounting', function() {
+      wrapper.unmount();
 
-      const repository1 = Repository.absent();
-      wrapper.setProps({repository: repository1});
-      assert.notStrictEqual(wrapper.state('remoteOperationObserver'), observer0);
+      simulateOperation(repository, 'fetch');
+      assert.isFalse(retry.called);
     });
   });