def setUp(self):
super(StatsTests, self).setUp()
self.stats = KanboardStats(board=self.board)
class StatsTests(KanboardTestCase):
def setUp(self):
super(StatsTests, self).setUp()
self.stats = KanboardStats(board=self.board)
def set_up_board(self, expected_counts, board=None, date=None):
if board is None:
board = self.board
if date is None:
date = datetime.date.today()
for phase_name, count in expected_counts.items():
phase = Phase.objects.get(title=phase_name, board=self.board)
for i in xrange(0, count):
card = self.create_card(phase=self.backlog,
backlogged_at=date,
board=board)
card.change_phase(phase, change_at=date)
def test_cycle_time(self):
board = {
u'Backlog': 4,
}
board_start = datetime.datetime.now() - datetime.timedelta(days=10)
self.set_up_board(board, date=board_start)
#With no cards done, the average should be 0
self.assertEqual(0, self.stats.cycle_time().days)
#Let's start a card 9 days ago and complete it today
nine_days_ago = datetime.datetime.now() - datetime.timedelta(days=9)
card = self.backlog.cards.all()[0]
card.change_phase(self.design, change_at=nine_days_ago)
card.change_phase(self.done)
self.assertEqual(9, self.stats.cycle_time().days)
#Let's start a card 5 days ago and complete it today
five_days_ago = datetime.datetime.now() - datetime.timedelta(days=5)
card = self.backlog.cards.all()[0]
card.change_phase(self.dev, change_at=five_days_ago)
card.change_phase(self.archive)
self.assertEqual(7, self.stats.cycle_time().days)
def test_lead_time(self):
board = {
u'Backlog': 4,
}
board_start = datetime.datetime.now() - datetime.timedelta(days=3)
self.set_up_board(board, date=board_start)
#With no cards done, the average should be 0
self.assertEqual(0, self.stats.lead_time().days)
#Complete a card one day ago, and our average should be 2 days
card = self.backlog.cards.all()[0]
one_day_ago = datetime.datetime.now() - datetime.timedelta(days=1)
card.change_phase(self.done, change_at=one_day_ago)
self.assertEqual(2, self.stats.lead_time().days)
self.assertEqual(0, self.stats.lead_time().seconds)
#Let's complete a card today making our average 2.5 days
card = self.backlog.cards.all()[1]
card.change_phase(self.done)
self.assertEqual(2, self.stats.lead_time().days) #2 days
self.assertEqual(12 * 60 * 60,
self.stats.lead_time().seconds) #12 hours
#Let's check that we can ask for lead time in the past
lead_time = self.stats.lead_time(start=one_day_ago, finish=one_day_ago)
self.assertEqual(2, lead_time.days)
self.assertEqual(0, lead_time.seconds)
#Let's check that we can ask for a lead time for just today
today = datetime.date.today()
lead_time = self.stats.lead_time(start=today)
self.assertEqual(3, lead_time.days)
def test_cumulative_flow(self):
expected = {
u'Backlog': 5,
u'Ideation': 2,
u'Design': 7,
u'Development': 3,
u'Testing': 6,
u'Deployment': 1,
u'Done': 3,
}
self.set_up_board(expected)
self.assertEqual(expected, self.stats.cumulative_flow())
card = self.test.cards.all()[0]
card.change_phase(self.deploy)
#Let's change some phases
expected[u'Testing'] = 5
expected[u'Deployment'] = 2
result = self.stats.cumulative_flow()
self.assertEqual(expected[u'Testing'], result[u'Testing'])
self.assertEqual(expected[u'Deployment'], result[u'Deployment'])
#let's try a backwards move
card = self.dev.cards.all()[0]
card.change_phase(self.design)
expected[u'Development'] = 2
expected[u'Design'] = 8
self.assertEqual(expected, self.stats.cumulative_flow())
def test_cumulative_flow_dates(self):
"""
cumulative_flow should be able to give us historical
data by date. Whenever data is missing (because
no moves were made) it should be extrapolated from
the previous log entry.
"""
four_days_ago = datetime.date.today() - datetime.timedelta(days=4)
three_days_ago = datetime.date.today() - datetime.timedelta(days=3)
two_days_ago = datetime.date.today() - datetime.timedelta(days=2)
one_day_ago = datetime.date.today() - datetime.timedelta(days=1)
three_ago_expected = {
u'Backlog': 5,
u'Ideation': 2,
u'Design': 5,
u'Development': 4,
u'Testing': 6,
u'Deployment': 2,
u'Done': 0,
}
self.set_up_board(three_ago_expected, date=three_days_ago)
self.assertEqual(three_ago_expected,
self.stats.cumulative_flow(three_days_ago))
#Change something one day ago
self.deploy.cards.all()[0].change_phase(self.done,
change_at=one_day_ago)
one_ago_expected = {
u'Backlog': 5,
u'Ideation': 2,
u'Design': 5,
u'Development': 4,
u'Testing': 6,
u'Deployment': 1,
u'Done': 1,
}
self.assertEqual(one_ago_expected,
self.stats.cumulative_flow(one_day_ago))
#Two days ago should equal three days ago.
self.assertEqual(three_ago_expected,
self.stats.cumulative_flow(two_days_ago))
#Test before the board was setup
four_ago_expected = {
u'Backlog': 0,
u'Ideation': 0,
u'Design': 0,
u'Development': 0,
u'Testing': 0,
u'Deployment': 0,
u'Done': 0,
}
self.assertEqual(four_ago_expected,
self.stats.cumulative_flow(four_days_ago))
