def test_mock_connection(self):
        # A connection with bad credentials fails
        failed_connection = create_mock_connection('wrong', 'info')
        assert_false(failed_connection)

        # A good connection has the correct parameters
        mock_connection = create_mock_connection()
        assert_equal(mock_connection.username, 'snowman')
        assert_equal(mock_connection.password, 'frosty')
        assert_equal(len(mock_connection.get_dataverses()), 3)
        assert_is_instance(mock_connection.get_dataverses()[0], Dataverse)
        assert_equal(
            mock_connection.get_dataverse(mock_connection.get_dataverses()[1].alias),
            mock_connection.get_dataverses()[1],
        )

    def test_fail_if_unauthorized_forbidden(self, mock_get_files, mock_connection):
        mock_connection.return_value = create_mock_connection()
        mock_get_files.return_value = [create_mock_draft_file('foo')]

        with assert_raises(HTTPError) as error:
            fail_if_unauthorized(self.node_settings, self.user.auth, 'bar')
            assert_equal(error.code, http.FORBIDDEN)

    def test_dataverse_release_study(self, mock_release, mock_connection):
        mock_connection.return_value = create_mock_connection()

        url = api_url_for('dataverse_release_study',
                          pid=self.project._primary_key)
        self.app.put(url, auth=self.user.auth)
        assert_true(mock_release.called)

    def test_serialize_settings_helper_returns_correct_auth_info(self, mock_connection):
        mock_connection.return_value = create_mock_connection()

        result = self.serializer.serialized_node_settings
        assert_equal(result['nodeHasAuth'], self.node_settings.has_auth)
        assert_true(result['userHasAuth'])
        assert_true(result['userIsOwner'])

    def test_dataverse_publish_dataset(self, mock_publish, mock_connection):
        mock_connection.return_value = create_mock_connection()

        url = api_url_for('dataverse_publish_dataset',
                          pid=self.project._primary_key)
        self.app.put(url, auth=self.user.auth)
        assert_true(mock_publish.called)

    def test_upload_existing(self, mock_get_by_id, mock_get, mock_delete,
                             mock_upload, mock_connection):
        mock_get.return_value = create_mock_draft_file()  # File already exists
        mock_get_by_id.return_value = None  # To confirm deletion happened
        mock_upload.return_value = {}
        mock_connection.return_value = create_mock_connection()

        # Define payload
        filename = 'myfile.rst'
        content = 'bazbaz'

        # Attempt to upload the file
        url = api_url_for('dataverse_upload_file',
                          pid=self.project._primary_key, name=filename)
        res = self.app.put(
            url,
            params=content,
            auth=self.user.auth,
            headers={'Content-Type': 'application/octet-stream'},
        )

        # Old file was deleted
        mock_delete.assert_called_once()

        # File was uploaded
        assert_equal(res.status_code, http.OK)
        mock_upload.assert_called_once()

        # Parameters are correct
        assert_equal(self.node_settings.study_hdl,
                     mock_upload.call_args[0][0].doi)
        assert_equal(filename, mock_upload.call_args[0][1])
        assert_equal(content, mock_upload.call_args[0][2])

    def test_upload_too_small(self, mock_get, mock_delete, mock_upload,
                             mock_connection):
        mock_get.return_value = create_mock_draft_file()  # File already exists
        mock_upload.return_value = {}
        mock_connection.return_value = create_mock_connection()

        # Define payload
        filename = 'myfile.rst'
        content = 'baz'

        # Attempt to upload the file
        url = api_url_for('dataverse_upload_file',
                          pid=self.project._primary_key, name=filename)
        res = self.app.put(
            url,
            params=content,
            auth=self.user.auth,
            headers={'Content-Type': 'application/octet-stream'},
            expect_errors=True,
        )

        # Old file was not deleted
        assert_false(mock_delete.call_count)

        # Bad request
        assert_equal(res.status_code, http.UNSUPPORTED_MEDIA_TYPE)
        assert_false(mock_upload.call_count)

    def test_dataverse_add_external_account_existing(self, mock_connection):
        mock_connection.return_value = create_mock_connection()
        host = 'myfakehost.data.verse'
        token = 'dont-use-this-token-in-other-tests'
        display_name = 'loaded_version'

        # Save an existing version
        external_account = ExternalAccount(
            provider='dataverse',
            provider_name='Dataverse',
            display_name=display_name,
            oauth_key=host,
            oauth_secret=token,
            provider_id=token,
        )
        external_account.save()

        url = api_url_for('dataverse_add_user_account')
        params = {'host': host, 'api_token': token}
        self.app.post_json(url, params, auth=self.user.auth)
        self.user.reload()

        assert_equal(len(self.user.external_accounts), 1)
        external_account = self.user.external_accounts[0]
        assert_equal(external_account.provider, 'dataverse')
        assert_equal(external_account.oauth_key, host)
        assert_equal(external_account.oauth_secret, token)
        # Ensure we got the loaded version
        assert_equal(external_account.display_name, display_name)

    def test_upload_file(self, mock_get, mock_upload, mock_connection):
        mock_upload.return_value = {}
        mock_connection.return_value = create_mock_connection()

        # Define payload
        filename = 'myfile.rst'
        content = 'bazbaz'

        # Upload the file
        url = api_url_for('dataverse_upload_file',
                          pid=self.project._primary_key, name=filename)
        res = self.app.put(
            url,
            params=content,
            auth=self.user.auth,
            headers={'Content-Type': 'application/octet-stream'},
        )

        # File was uploaded
        assert_equal(res.status_code, http.CREATED)
        mock_upload.assert_called_once()

        # Parameters are correct
        assert_equal(self.node_settings.study_hdl,
                     mock_upload.call_args[0][0].doi)
        assert_equal(filename, mock_upload.call_args[0][1])
        assert_equal(content, mock_upload.call_args[0][2])

    def test_set_dataverse_and_dataset(self, mock_connection):
        mock_connection.return_value = create_mock_connection()

        url = api_url_for('dataverse_set_config',
                          pid=self.project._primary_key)
        params = {
            'dataverse': {'alias': 'ALIAS3'},
            'dataset': {'doi': 'doi:12.3456/DVN/00003'},
        }

        # Select a different dataset
        self.app.post_json(url, params, auth=self.user.auth)
        self.project.reload()
        self.node_settings.reload()

        # New dataset was selected
        assert_equal(self.node_settings.dataverse_alias, 'ALIAS3')
        assert_equal(self.node_settings.dataset, 'Example (DVN/00003)')
        assert_equal(self.node_settings.dataset_doi, 'doi:12.3456/DVN/00003')
        assert_equal(self.node_settings.dataset_id, '18')

        # Log states that a dataset was selected
        last_log = self.project.logs[-1]
        assert_equal(last_log.action, 'dataverse_dataset_linked')
        log_params = last_log.params
        assert_equal(log_params['node'], self.project._primary_key)
        assert_is_none(log_params['project'])
        assert_equal(log_params['dataset'], 'Example (DVN/00003)')

    def test_set_dataverse_no_dataset(self, mock_connection):
        mock_connection.return_value = create_mock_connection()
        num_old_logs = len(self.project.logs)

        url = api_url_for('dataverse_set_config',
                          pid=self.project._primary_key)
        params = {
            'dataverse': {'alias': 'ALIAS3'},
            'dataset': {},    # The dataverse has no datasets
        }

        # Select a different dataset
        res = self.app.post_json(url, params, auth=self.user.auth,
                                 expect_errors=True)
        self.node_settings.reload()

        # Old settings did not change
        assert_equal(res.status_code, http.BAD_REQUEST)
        assert_equal(self.node_settings.dataverse_alias, 'ALIAS2')
        assert_equal(self.node_settings.dataset, 'Example (DVN/00001)')
        assert_equal(self.node_settings.dataset_doi, 'doi:12.3456/DVN/00001')

        # Nothing was logged
        self.project.reload()
        assert_equal(len(self.project.logs), num_old_logs)

    def test_dataverse_root_not_published(self, mock_files, mock_connection):
        mock_connection.return_value = create_mock_connection()
        mock_files.return_value = []

        self.project.set_privacy('public')
        self.project.save()

        alias = self.node_settings.dataverse_alias
        doi = self.node_settings.dataset_doi
        external_account = create_external_account()
        self.user.external_accounts.append(external_account)
        self.user.save()
        self.node_settings.set_auth(external_account, self.user)
        self.node_settings.dataverse_alias = alias
        self.node_settings.dataset_doi = doi
        self.node_settings.save()

        url = api_url_for('dataverse_root_folder_public',
                          pid=self.project._primary_key)

        # Contributor gets draft, no options
        res = self.app.get(url, auth=self.user.auth)
        assert_true(res.json[0]['permissions']['edit'])
        assert_false(res.json[0]['hasPublishedFiles'])
        assert_equal(res.json[0]['version'], 'latest')

        # Non-contributor gets nothing
        user2 = AuthUserFactory()
        res = self.app.get(url, auth=user2.auth)
        assert_equal(res.json, [])

    def test_set_user_config_fail(self, mock_connection):

        mock_connection.return_value = create_mock_connection('wrong', 'info')

        # Create a user with no settings
        user = AuthUserFactory()
        user.add_addon('dataverse')
        user_settings = user.get_addon('dataverse')

        url = api_url_for('dataverse_set_user_config')
        params = {'dataverse_username': 'wrong',
                  'dataverse_password': 'info'}

        # Post incorrect credentials to existing user
        res = self.app.post_json(url, params, auth=self.user.auth,
                                 expect_errors=True)
        self.user_settings.reload()

        # Original user's info has not changed
        assert_equal(res.status_code, http.UNAUTHORIZED)
        assert_equal(self.user_settings.dataverse_username, 'snowman')
        assert_equal(self.user_settings.dataverse_password, 'frosty')

        # Post incorrect credentials to new user
        res = self.app.post_json(url, params, auth=user.auth,
                                 expect_errors=True)
        user_settings.reload()

        # New user's incorrect credentials were not saved
        assert_equal(res.status_code, http.UNAUTHORIZED)
        assert_equal(user_settings.dataverse_username, None)
        assert_equal(user_settings.dataverse_password, None)

    def test_upload_existing(self, mock_get_by_id, mock_get, mock_delete,
                             mock_upload, mock_connection):
        mock_get.return_value = create_mock_draft_file()  # File already exists
        mock_get_by_id.return_value = None  # To confirm deletion happened
        mock_upload.return_value = {}
        mock_connection.return_value = create_mock_connection()

        # Define payload
        filename = 'myfile.rst'
        content = 'bazbaz'
        path = '54321'
        payload = {'file': Upload(filename, content,'text/x-rst')}

        # Attempt to upload the file
        url = api_url_for('dataverse_upload_file',
                          pid=self.project._primary_key, path=path)
        res = self.app.post(url, payload, auth=self.user.auth)

        # Old file was deleted
        mock_delete.assert_called_once

        # File was uploaded
        assert_equal(res.status_code, http.CREATED)
        mock_upload.assert_called_once

        # Parameters are correct
        assert_equal(self.node_settings.study_hdl,
                     mock_upload.call_args[0][0].doi)
        assert_equal(filename, mock_upload.call_args[0][1])
        assert_equal(content, mock_upload.call_args[0][2])
        assert_equal('file_updated', json.loads(res.body)['actionTaken'])

 def test_mock_connection(self):
     mock_connection = create_mock_connection()
     assert_equal(mock_connection.token, 'snowman-frosty')
     assert_equal(len(mock_connection.get_dataverses()), 3)
     assert_is_instance(mock_connection.get_dataverses()[0], Dataverse)
     assert_equal(
         mock_connection.get_dataverse(mock_connection.get_dataverses()[1].alias),
         mock_connection.get_dataverses()[1],
     )

 def setUp(self):
     super(TestDataverseSerializer, self).setUp()
     self.ser = self.Serializer(
         user_settings=self.user_settings,
         node_settings=self.node_settings
     )
     self.mock_api = mock.patch('website.addons.dataverse.serializer.client.connect_from_settings')
     self.mock_api.return_value = create_mock_connection()
     self.mock_api.start()

    def test_dataverse_root_no_connection(self, mock_files, mock_connection):
        mock_connection.return_value = create_mock_connection()
        mock_files.return_value = ['mock_file']

        url = api_url_for('dataverse_root_folder_public',
                          pid=self.project._primary_key)

        mock_connection.return_value = None
        res = self.app.get(url, auth=self.user.auth)
        assert_equal(res.json, [])

    def test_dataverse_publish_both(self, mock_publish_dv, mock_publish_ds, mock_connection):
        mock_connection.return_value = create_mock_connection()

        url = api_url_for('dataverse_publish_dataset',
                          pid=self.project._primary_key)
        self.app.put_json(url, params={'publish_both': True}, auth=self.user.auth)

        # Both Dataverse and dataset were published
        assert_true(mock_publish_dv.called)
        assert_true(mock_publish_ds.called)

    def test_serialize_settings_helper_returns_dv_info(self, mock_connection):
        mock_connection.return_value = create_mock_connection()

        result = serialize_settings(self.node_settings, self.user)

        assert_equal(len(result['dataverses']), 3)
        assert_equal(result['savedDataverse']['title'], self.node_settings.dataverse)
        assert_equal(result['savedDataverse']['alias'], self.node_settings.dataverse_alias)
        assert_equal(result['savedDataset']['title'], self.node_settings.dataset)
        assert_equal(result['savedDataset']['doi'], self.node_settings.dataset_doi)

    def test_dataverse_data_contents_no_connection(self, mock_request, mock_connection):
        mock_connection.return_value = create_mock_connection()
        mock_request.referrer = 'some_url/files/'

        # If there is no connection, no files are returned
        mock_connection.return_value = None
        url = api_url_for('dataverse_hgrid_data_contents',
                          pid=self.project._primary_key)
        res = self.app.get(url, auth=self.user.auth)
        assert_equal(res.json, [])