380 lines
16 KiB
Python
380 lines
16 KiB
Python
# -*- coding: utf-8; -*-
|
|
|
|
import datetime
|
|
from unittest.mock import patch, MagicMock
|
|
|
|
from sqlalchemy import orm
|
|
from pyramid.httpexceptions import HTTPFound
|
|
|
|
from wuttjamaican.db import model
|
|
from wuttjamaican.batch import BatchHandler
|
|
from wuttaweb.views import MasterView, batch as mod
|
|
from wuttaweb.progress import SessionProgress
|
|
from wuttaweb.testing import WebTestCase
|
|
|
|
|
|
class MockBatch(model.BatchMixin, model.Base):
|
|
__tablename__ = 'testing_batch_mock'
|
|
|
|
class MockBatchRow(model.BatchRowMixin, model.Base):
|
|
__tablename__ = 'testing_batch_mock_row'
|
|
__batch_class__ = MockBatch
|
|
|
|
MockBatch.__row_class__ = MockBatchRow
|
|
|
|
class MockBatchHandler(BatchHandler):
|
|
model_class = MockBatch
|
|
|
|
|
|
class TestBatchMasterView(WebTestCase):
|
|
|
|
def setUp(self):
|
|
self.setup_web()
|
|
|
|
# nb. create MockBatch, MockBatchRow
|
|
model.Base.metadata.create_all(bind=self.session.bind)
|
|
|
|
def make_handler(self):
|
|
return MockBatchHandler(self.config)
|
|
|
|
def make_view(self):
|
|
return mod.BatchMasterView(self.request)
|
|
|
|
def test_get_batch_handler(self):
|
|
self.assertRaises(NotImplementedError, mod.BatchMasterView, self.request)
|
|
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=42):
|
|
view = mod.BatchMasterView(self.request)
|
|
self.assertEqual(view.batch_handler, 42)
|
|
|
|
def test_get_fallback_templates(self):
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
view = self.make_view()
|
|
templates = view.get_fallback_templates('view')
|
|
self.assertEqual(templates, [
|
|
'/batch/view.mako',
|
|
'/master/view.mako',
|
|
])
|
|
|
|
def test_render_to_response(self):
|
|
model = self.app.model
|
|
handler = MockBatchHandler(self.config)
|
|
|
|
user = model.User(username='barney')
|
|
self.session.add(user)
|
|
batch = handler.make_batch(self.session, created_by=user)
|
|
self.session.add(batch)
|
|
self.session.flush()
|
|
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
with patch.object(MasterView, 'render_to_response') as render_to_response:
|
|
view = self.make_view()
|
|
response = view.render_to_response('view', {'instance': batch})
|
|
self.assertTrue(render_to_response.called)
|
|
context = render_to_response.call_args[0][1]
|
|
self.assertIs(context['batch'], batch)
|
|
self.assertIs(context['batch_handler'], handler)
|
|
|
|
def test_configure_grid(self):
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.multiple(mod.BatchMasterView, create=True, model_class=MockBatch):
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
view = mod.BatchMasterView(self.request)
|
|
grid = view.make_model_grid()
|
|
# nb. coverage only; tests nothing
|
|
view.configure_grid(grid)
|
|
|
|
def test_render_batch_id(self):
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
view = mod.BatchMasterView(self.request)
|
|
batch = MockBatch(id=42)
|
|
|
|
result = view.render_batch_id(batch, 'id', 42)
|
|
self.assertEqual(result, '00000042')
|
|
|
|
result = view.render_batch_id(batch, 'id', None)
|
|
self.assertIsNone(result)
|
|
|
|
def test_get_instance_title(self):
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
view = mod.BatchMasterView(self.request)
|
|
|
|
batch = MockBatch(id=42)
|
|
result = view.get_instance_title(batch)
|
|
self.assertEqual(result, "00000042")
|
|
|
|
batch = MockBatch(id=43, description="runnin some numbers")
|
|
result = view.get_instance_title(batch)
|
|
self.assertEqual(result, "00000043 runnin some numbers")
|
|
|
|
def test_configure_form(self):
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.multiple(mod.BatchMasterView, create=True, model_class=MockBatch):
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
view = mod.BatchMasterView(self.request)
|
|
|
|
# creating
|
|
with patch.object(view, 'creating', new=True):
|
|
form = view.make_model_form(model_instance=None)
|
|
view.configure_form(form)
|
|
|
|
batch = MockBatch(id=42)
|
|
|
|
# viewing
|
|
with patch.object(view, 'viewing', new=True):
|
|
form = view.make_model_form(model_instance=batch)
|
|
view.configure_form(form)
|
|
|
|
# editing
|
|
with patch.object(view, 'editing', new=True):
|
|
form = view.make_model_form(model_instance=batch)
|
|
view.configure_form(form)
|
|
|
|
# deleting
|
|
with patch.object(view, 'deleting', new=True):
|
|
form = view.make_model_form(model_instance=batch)
|
|
view.configure_form(form)
|
|
|
|
# viewing (executed)
|
|
batch.executed = datetime.datetime.now()
|
|
with patch.object(view, 'viewing', new=True):
|
|
form = view.make_model_form(model_instance=batch)
|
|
view.configure_form(form)
|
|
|
|
def test_objectify(self):
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.multiple(mod.BatchMasterView, create=True, model_class=MockBatch):
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
with patch.object(mod.BatchMasterView, 'Session', return_value=self.session):
|
|
view = mod.BatchMasterView(self.request)
|
|
|
|
# create batch
|
|
with patch.object(view, 'creating', new=True):
|
|
form = view.make_model_form(model_instance=None)
|
|
form.validated = {}
|
|
batch = view.objectify(form)
|
|
self.assertIsInstance(batch.id, int)
|
|
self.assertTrue(batch.id > 0)
|
|
|
|
# edit batch
|
|
with patch.object(view, 'editing', new=True):
|
|
with patch.object(view.batch_handler, 'make_batch') as make_batch:
|
|
form = view.make_model_form(model_instance=batch)
|
|
form.validated = {'description': 'foo'}
|
|
self.assertIsNone(batch.description)
|
|
batch = view.objectify(form)
|
|
self.assertEqual(batch.description, 'foo')
|
|
|
|
def test_redirect_after_create(self):
|
|
self.pyramid_config.add_route('mock_batches.view', '/batch/mock/{uuid}')
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
with patch.multiple(mod.BatchMasterView, create=True,
|
|
model_class=MockBatch,
|
|
route_prefix='mock_batches'):
|
|
view = mod.BatchMasterView(self.request)
|
|
batch = MockBatch(id=42)
|
|
|
|
# typically redirect to view batch
|
|
result = view.redirect_after_create(batch)
|
|
self.assertIsInstance(result, HTTPFound)
|
|
|
|
# unless populating in which case thread is launched
|
|
self.request.session.id = 'abcdefghijk'
|
|
with patch.object(mod, 'threading') as threading:
|
|
thread = MagicMock()
|
|
threading.Thread.return_value = thread
|
|
with patch.object(view.batch_handler, 'should_populate', return_value=True):
|
|
with patch.object(view, 'render_progress') as render_progress:
|
|
view.redirect_after_create(batch)
|
|
self.assertTrue(threading.Thread.called)
|
|
thread.start.assert_called_once_with()
|
|
self.assertTrue(render_progress.called)
|
|
|
|
def test_delete_instance(self):
|
|
model = self.app.model
|
|
handler = self.make_handler()
|
|
|
|
user = model.User(username='barney')
|
|
self.session.add(user)
|
|
|
|
batch = handler.make_batch(self.session, created_by=user)
|
|
self.session.add(batch)
|
|
self.session.flush()
|
|
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
view = self.make_view()
|
|
|
|
self.assertEqual(self.session.query(MockBatch).count(), 1)
|
|
view.delete_instance(batch)
|
|
self.assertEqual(self.session.query(MockBatch).count(), 0)
|
|
|
|
def test_populate_thread(self):
|
|
model = self.app.model
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
with patch.multiple(mod.BatchMasterView, create=True, model_class=MockBatch):
|
|
view = mod.BatchMasterView(self.request)
|
|
user = model.User(username='barney')
|
|
self.session.add(user)
|
|
batch = MockBatch(id=42, created_by=user)
|
|
self.session.add(batch)
|
|
self.session.commit()
|
|
|
|
# nb. use our session within thread method
|
|
with patch.object(self.app, 'make_session', return_value=self.session):
|
|
|
|
# nb. prevent closing our session
|
|
with patch.object(self.session, 'close') as close:
|
|
|
|
# without progress
|
|
view.populate_thread(batch.uuid)
|
|
close.assert_called_once_with()
|
|
close.reset_mock()
|
|
|
|
# with progress
|
|
self.request.session.id = 'abcdefghijk'
|
|
view.populate_thread(batch.uuid,
|
|
progress=SessionProgress(self.request,
|
|
'populate_mock_batch'))
|
|
close.assert_called_once_with()
|
|
close.reset_mock()
|
|
|
|
# failure to populate, without progress
|
|
with patch.object(view.batch_handler, 'do_populate', side_effect=RuntimeError):
|
|
view.populate_thread(batch.uuid)
|
|
close.assert_called_once_with()
|
|
close.reset_mock()
|
|
|
|
# failure to populate, with progress
|
|
with patch.object(view.batch_handler, 'do_populate', side_effect=RuntimeError):
|
|
view.populate_thread(batch.uuid,
|
|
progress=SessionProgress(self.request,
|
|
'populate_mock_batch'))
|
|
close.assert_called_once_with()
|
|
close.reset_mock()
|
|
|
|
# failure for batch to appear
|
|
self.session.delete(batch)
|
|
self.session.commit()
|
|
# nb. should give up waiting after 1 second
|
|
self.assertRaises(RuntimeError, view.populate_thread, batch.uuid)
|
|
|
|
def test_execute(self):
|
|
self.pyramid_config.add_route('mock_batches.view', '/batch/mock/{uuid}')
|
|
model = self.app.model
|
|
handler = MockBatchHandler(self.config)
|
|
|
|
user = model.User(username='barney')
|
|
self.session.add(user)
|
|
batch = handler.make_batch(self.session, created_by=user)
|
|
self.session.add(batch)
|
|
self.session.commit()
|
|
|
|
with patch.multiple(mod.BatchMasterView, create=True,
|
|
model_class=MockBatch,
|
|
route_prefix='mock_batches',
|
|
get_batch_handler=MagicMock(return_value=handler),
|
|
get_instance=MagicMock(return_value=batch)):
|
|
view = self.make_view()
|
|
|
|
# batch executes okay
|
|
response = view.execute()
|
|
self.assertEqual(response.status_code, 302) # redirect to "view batch"
|
|
self.assertFalse(self.request.session.peek_flash('error'))
|
|
|
|
# but cannot be executed again
|
|
response = view.execute()
|
|
self.assertEqual(response.status_code, 302) # redirect to "view batch"
|
|
# nb. flash has error this time
|
|
self.assertTrue(self.request.session.peek_flash('error'))
|
|
|
|
def test_get_row_model_class(self):
|
|
handler = MockBatchHandler(self.config)
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
view = self.make_view()
|
|
|
|
self.assertRaises(AttributeError, view.get_row_model_class)
|
|
|
|
# row class determined from batch class
|
|
with patch.object(mod.BatchMasterView, 'model_class', new=MockBatch, create=True):
|
|
cls = view.get_row_model_class()
|
|
self.assertIs(cls, MockBatchRow)
|
|
|
|
self.assertRaises(AttributeError, view.get_row_model_class)
|
|
|
|
# view may specify row class
|
|
with patch.object(mod.BatchMasterView, 'row_model_class', new=MockBatchRow, create=True):
|
|
cls = view.get_row_model_class()
|
|
self.assertIs(cls, MockBatchRow)
|
|
|
|
def test_get_row_grid_data(self):
|
|
handler = MockBatchHandler(self.config)
|
|
model = self.app.model
|
|
|
|
user = model.User(username='barney')
|
|
self.session.add(user)
|
|
|
|
batch = handler.make_batch(self.session, created_by=user)
|
|
self.session.add(batch)
|
|
row = handler.make_row()
|
|
handler.add_row(batch, row)
|
|
self.session.flush()
|
|
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
|
|
view = self.make_view()
|
|
self.assertRaises(AttributeError, view.get_row_grid_data, batch)
|
|
|
|
Session = MagicMock(return_value=self.session)
|
|
Session.query.side_effect = lambda m: self.session.query(m)
|
|
with patch.multiple(mod.BatchMasterView, create=True,
|
|
Session=Session,
|
|
model_class=MockBatch):
|
|
|
|
view = self.make_view()
|
|
data = view.get_row_grid_data(batch)
|
|
self.assertIsInstance(data, orm.Query)
|
|
self.assertEqual(data.count(), 1)
|
|
|
|
def test_configure_row_grid(self):
|
|
handler = MockBatchHandler(self.config)
|
|
model = self.app.model
|
|
|
|
user = model.User(username='barney')
|
|
self.session.add(user)
|
|
|
|
batch = handler.make_batch(self.session, created_by=user)
|
|
self.session.add(batch)
|
|
row = handler.make_row()
|
|
handler.add_row(batch, row)
|
|
self.session.flush()
|
|
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=handler):
|
|
|
|
Session = MagicMock(return_value=self.session)
|
|
Session.query.side_effect = lambda m: self.session.query(m)
|
|
with patch.multiple(mod.BatchMasterView, create=True,
|
|
Session=Session,
|
|
model_class=MockBatch):
|
|
|
|
with patch.object(self.request, 'matchdict', new={'uuid': batch.uuid}):
|
|
view = self.make_view()
|
|
grid = view.make_row_model_grid(batch)
|
|
self.assertIn('sequence', grid.labels)
|
|
self.assertEqual(grid.labels['sequence'], "Seq.")
|
|
|
|
def test_render_row_status(self):
|
|
with patch.object(mod.BatchMasterView, 'get_batch_handler', return_value=None):
|
|
view = self.make_view()
|
|
row = MagicMock(foo=1, STATUS={1: 'bar'})
|
|
self.assertEqual(view.render_row_status(row, 'foo', 1), 'bar')
|
|
|
|
def test_defaults(self):
|
|
# nb. coverage only
|
|
with patch.object(mod.BatchMasterView, 'model_class', new=MockBatch, create=True):
|
|
mod.BatchMasterView.defaults(self.pyramid_config)
|