def test_agent_crop_receipt_inventory(self):
farmer1 = utils.create_farmer(msisdn="27700000000")
farmer2 = utils.create_farmer(msisdn="27700000001")
market = utils.create_market("market", farmer1.districts.all()[0])
agent = utils.create_agent()
receipt1 = utils.take_in(market, agent, farmer1, 10, 'box', 'tomato')
receipt2 = utils.take_in(market, agent, farmer2, 10, 'box', 'onion')
self.assertEqual([receipt1],
list(agent.cropreceipts_available_for(farmer1)))
self.assertEqual([receipt2],
list(agent.cropreceipts_available_for(farmer2)))
def test_farmer_id_number_uniqueness(self):
# Test that we cannot create farmers with the same id number
farmer = utils.create_farmer(msisdn='123')
farmer.id_number = '123456789'
farmer.save()
# Test that we cannot create farmers with the same id number
farmer = utils.create_farmer(msisdn='456') # different msisdn
farmer.id_number = '123456789' # same id_number
self.assertRaises(IntegrityError, farmer.save)
def test_farmer_match(self):
def match(*args, **kw):
return sorted(Farmer.match(*args, **kw),
key=lambda x: x.actor.user.first_name)
joe = utils.create_farmer(name="joe", msisdn="1")
[joe_msisdn] = joe.actor.get_msisdns()
bob = utils.create_farmer(name="bob", msisdn="2", id_number="1234")
self.assertEqual(match(), [])
self.assertEqual(match(id_number=bob.id_number), [bob])
self.assertEqual(match(msisdns=[joe_msisdn]), [joe])
self.assertEqual(match(msisdns=[joe_msisdn], id_number=bob.id_number),
[bob, joe])
def test_identity_pin_auth(self):
farmer = utils.create_farmer()
identity = Identity(actor=farmer.actor, msisdn='1234')
identity.set_pin('5678')
identity.save()
self.assertTrue(identity.check_pin('5678'))
self.assertFalse(identity.check_pin('4567'))
def test_write_note(self):
farmer = utils.create_farmer()
agent = utils.create_agent()
note = agent.write_note(farmer, 'this is a note about the farmer')
self.assertIn(note, Note.objects.all())
self.assertIn(note, farmer.actor.attachednote_set.all())
self.assertIn(note, agent.notes_for(farmer))
def test_farmer_creation_duplicate_null_id_number(self):
"""
Replicate duplicate ID number bug, only occurs in
post data as None is converted to a string.
"""
utils.create_farmer(name="joe_1")
url = reverse("fncs:farmer_new")
data_1 = {"name": "name_1",
"surname": "surname_1",
"msisdn1": "123456781",
"gender": "M",
"markets": [1, 2]}
self.client.post(url, data=data_1, follow=True)
farmer = Farmer.objects.get(actor__user__username="******")
self.assertEquals(farmer.actor.user.first_name, "name_1")
self.assertEquals(farmer.id_number, None)
def test_find_identity(self):
farmer = utils.create_farmer()
identity = farmer.actor.add_identity('1234', '1234')
self.assertEquals(farmer.actor.get_identity('1234'), identity)
self.assertEquals(Actor.find('1234'), farmer.actor)
self.assertEquals(Actor.find_with_pin('1234', '1234'), farmer.actor)
self.assertRaises(ActorException, Actor.find_with_pin, '1234',
'bad-pin')
def test_login_with_identity(self):
farmer = utils.create_farmer(msisdn='1234')
farmer.actor.add_identity('6789', '6789')
# Log in with the new identity
client = Client()
client.login(username='******', password='******')
response = client.get(reverse('fncs:home'))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['user'],
farmer.actor.user)
def test_farmer_crop_setting(self):
farmer = utils.create_farmer()
crop1 = utils.create_crop("apples")
crop2 = utils.create_crop("oranges")
crop3 = utils.create_crop("potatoes")
farmer.grows_crop(crop1)
self.assertIn(crop1, farmer.crops.all())
farmer.grows_crops_exclusively([crop2, crop3])
self.assertNotIn(crop1, farmer.crops.all())
self.assertIn(crop2, farmer.crops.all())
self.assertIn(crop3, farmer.crops.all())
def test_crops(self):
farmer = utils.create_farmer()
market = utils.create_market("market", farmer.districts.all()[0])
agent = utils.create_agent()
crop = utils.create_crop("potatoes")
unit = utils.create_crop_unit("boxes")
amount = 10
receipt = agent.take_in_crop(market, farmer, amount, unit, crop)
self.assertEquals(list(market.crops()), [crop])
def test_farmer_market_setting(self):
farmer = utils.create_farmer()
market1 = utils.create_market("market 1", farmer.districts.all()[0])
market2 = utils.create_market("market 2", farmer.districts.all()[0])
market3 = utils.create_market("market 3", farmer.districts.all()[0])
# prime the farmer with 1 market
farmer.markets.add(market1)
# test the destructive set
farmer.operates_at_markets_exclusively([market2, market3])
self.assertNotIn(market1, farmer.markets.all())
self.assertIn(market2, farmer.markets.all())
self.assertIn(market3, farmer.markets.all())
def test_fba_farmer_registration(self):
fba1 = utils.create_fba(msisdn='0')
fba2 = utils.create_fba(msisdn='1')
farmer1 = utils.create_farmer(msisdn='1234', name='farmer1')
farmer2 = utils.create_farmer(msisdn='5678', name='farmer2')
# Each should register 1 farmer first
fba1.register_farmer(farmer1)
fba2.register_farmer(farmer2)
# Then the second farmer
fba1.register_farmer(farmer2)
fba2.register_farmer(farmer1)
# both should 'know' each farmer
farmers = set([farmer1, farmer2])
self.assertEqual(farmers, set(fba1.get_farmers()))
self.assertEqual(farmers, set(fba2.get_farmers()))
# Each should only have 1 farmer as a registered farmer
self.assertEqual([farmer1], list(fba1.get_registered_farmers()))
self.assertEqual([farmer2], list(fba2.get_registered_farmers()))
def test_farmer_matching_on_msisdn(self):
farmer = utils.create_farmer()
msisdn = farmer.actor.get_msisdns()[0]
self.assertTrue(utils.is_farmer(msisdn))
# Now we try & recreate a farmer with a known MSISDN, should give us a
# matching suggestion
response = self.client.post(reverse('fncs:farmer_new'), {
'msisdn1': msisdn,
'name': 'name',
'surname': 'surname',
'markets': [self.market.pk],
'gender': 'M',
})
self.assertEqual(response.status_code, 200)
self.assertContains(response, farmer.actor.name)
def test_farmer_agent_link(self):
farmer = utils.create_farmer()
market = utils.create_market("market", farmer.districts.all()[0])
agent = utils.create_agent()
crop = utils.create_crop("potatoes")
unit = utils.create_crop_unit("boxes")
amount = 10
agent.take_in_crop(market, farmer, amount, unit, crop)
self.assertTrue(agent.is_selling_for(farmer, market))
self.assertIn(market, agent.markets.all())
self.assertIn(farmer, agent.farmers.all())
self.assertIn(market, farmer.markets.all())
def test_price_history(self):
farmer = utils.create_farmer()
market = utils.create_market("market", farmer.districts.all()[0])
agent = utils.create_agent()
crop = utils.create_crop("potatoes")
unit = utils.create_crop_unit("boxes")
price = 20
amount = 10
for i in range(100):
receipt = agent.take_in_crop(market, farmer, amount, unit, crop)
transaction = agent.register_sale(receipt, amount, price)
price_history = Transaction.price_history_for(market, crop, unit)
self.assertEquals(list(price_history), [20.0] * 100)
def test_farmer_matching_on_id_number(self):
farmer = utils.create_farmer()
farmer.id_number = '1234'
farmer.save()
# Now we try & recreate a farmer with a known MSISDN, should give us a
# matching suggestion
response = self.client.post(reverse('fncs:farmer_new'), {
'msisdn1': '123123123123',
'id_number': farmer.id_number, # same as previous farmer
'name': 'name',
'surname': 'surname',
'markets': [self.market.pk],
'gender': 'M',
})
self.assertEqual(response.status_code, 200)
self.assertContains(response, farmer.actor.name)
def create_highest_markets(self, prices):
farmer = utils.create_farmer()
markets = [
utils.create_market("market %d" % i, farmer.districts.all()[0])
for i in range(len(prices))]
crop = utils.create_crop("potatoes")
unit = utils.create_crop_unit("boxes")
agent = utils.create_agent()
amount = 10
for market, price in zip(markets, prices):
for i in range(10):
receipt = agent.take_in_crop(market, farmer, amount, unit,
crop)
agent.register_sale(receipt, amount, price)
return crop, markets
def test_farmer_districts(self):
province = utils.create_province("province")
district1 = utils.create_district("district 1", province)
market1 = utils.create_market("market 1", district1)
district2 = utils.create_district("district 2", province)
market2 = utils.create_market("market 2", district2)
farmer = utils.create_farmer()
agent1 = utils.create_agent("agent 1")
agent2 = utils.create_agent("agent 2")
farmer.operates_at(market1, agent1)
farmer.operates_at(market2, agent2)
self.assertEquals(farmer.market_districts().count(), 2)
self.assertIn(district1, farmer.market_districts())
self.assertIn(district2, farmer.market_districts())
def test_farmer_matching_redirect(self):
farmer = utils.create_farmer()
msisdn = farmer.actor.get_msisdns()[0]
other_agent = utils.create_agent(msisdn='1')
farmer.operates_at(self.market, other_agent)
response = self.client.post(reverse('fncs:farmer_new'), {
'msisdn1': msisdn,
'name': 'name',
'surname': 'surname',
'markets': [self.market.pk],
'matched_farmer': farmer.pk,
'gender': 'M',
})
self.assertRedirects(response, reverse('fncs:farmer_edit', kwargs={
'farmer_pk': farmer.pk,
}))
farmer = Farmer.objects.get(pk=farmer.pk)
self.assertEqual(set([other_agent, self.agent]),
set(farmer.agent_farmer.all()))
def test_agent_sale(self):
farmer = utils.create_farmer()
market = utils.create_market("market", farmer.districts.all()[0])
agent = utils.create_agent()
crop = utils.create_crop("potatoes")
unit = utils.create_crop_unit("boxes")
price = 20
amount = 10
# create inventory
receipt = agent.take_in_crop(market, farmer, amount, unit, crop)
self.assertTrue(receipt.remaining_inventory(), 10)
transaction = agent.register_sale(receipt, amount, price)
self.assertTrue(agent.is_selling_for(farmer, market))
self.assertIn(market, agent.markets.all())
self.assertIn(farmer, agent.farmers.all())
# test the transaction aspect
self.assertEquals(transaction.total, 200.0)
self.assertEquals(transaction.price, price)
self.assertEquals(transaction.amount, amount)
# test the selling out of the inventory
crop_receipt = transaction.crop_receipt
self.assertEquals(crop_receipt.crop, crop)
self.assertEquals(crop_receipt.unit, unit)
self.assertEquals(crop_receipt.agent, agent)
self.assertEquals(crop_receipt.farmer, farmer)
self.assertEquals(crop_receipt.market, market)
# had 20 crops in inventory, inventory should be reconciled
# and the calculated stock count should reflect this
self.assertEquals(crop_receipt.amount, 10)
self.assertTrue(crop_receipt.reconciled)
self.assertEquals(crop_receipt.remaining_inventory(), 0)
self.assertAlmostEqual(transaction.created_at, datetime.now(),
delta=timedelta(seconds=2))
self.assertIn(transaction, farmer.transactions())
self.assertTrue(farmer.is_growing_crop(crop))
self.assertIn(transaction, agent.sales_for(farmer))
def generate_farmers(self, msisdns, agent):
for msisdn in msisdns:
# create a district
district = utils.random_district()
farmergroup_name = "%s Farmer Group" % (district.name,)
# create the farmer
farmer = utils.create_farmer(msisdn=str(msisdn),
name=utils.random_name(),
surname=utils.random_surname(),
)
# cultivates two types of crops
farmer.grows_crop(utils.random_crop())
farmer.grows_crop(utils.random_crop())
# create a market in the district
market_name = '%s Market' % district.name
market = utils.create_market(market_name, district)
# have the farmer sells crops at that market through the agent
farmer.operates_at(market, agent)
def test_farmer_grows_crops(self):
farmer = utils.create_farmer()
crop = utils.random_crop()
farmer.grows_crop(crop)
self.assertIn(crop, farmer.crops.all())
def test_farmer_creation(self):
farmer = utils.create_farmer(name="joe")
self.assertEquals(farmer.actor.user.first_name, "joe")
self.assertEquals(farmer.agent_farmer.count(), 0)
def create_farmer_for_agent(agent, market, **kwargs):
farmer = utils.create_farmer(**kwargs)
farmer.operates_at(market, agent)
return farmer
def test_send_farmer_message(self):
farmer = utils.create_farmer()
agent = utils.create_agent()
message = agent.actor.send_message_to_farmer(farmer, 'hello world')
self.assertIn(message, Message.objects.filter(sender=agent.actor,
recipient=farmer.actor))
