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))