Beispiel #1
0
	def test_multi_currency(self):
		customer = frappe.get_doc("Customer", "_Test Customer USD")
		
		create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC", 
			currency="USD", conversion_rate=50)
		
		customer.party_account_currency = "EUR"
		self.assertRaises(InvalidCurrency, customer.save)
		
    def _test_sales_invoice_return(self, item_code, delivered_qty, returned_qty):
        from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice

        si = create_sales_invoice(item_code=item_code, qty=delivered_qty)

        se = make_stock_entry(
            item_code="_Test Item",
            target="_Test Warehouse - _TC",
            qty=returned_qty,
            purpose="Sales Return",
            sales_invoice_no=si.name,
            do_not_save=True,
        )
        self.assertRaises(NotUpdateStockError, se.insert)

        make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=200, incoming_rate=100)

        # check currency available qty in bin
        actual_qty_0 = get_qty_after_transaction()

        # insert a pos invoice with update stock
        si = create_sales_invoice(update_stock=1, item_code=item_code, qty=5)

        # check available bin qty after invoice submission
        actual_qty_1 = get_qty_after_transaction()

        self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1)

        # check if item is validated
        se = make_stock_entry(
            item_code="_Test Item Home Desktop 200",
            target="_Test Warehouse - _TC",
            qty=returned_qty,
            purpose="Sales Return",
            sales_invoice_no=si.name,
            do_not_save=True,
        )

        self.assertRaises(frappe.DoesNotExistError, se.insert)

        # try again
        se = make_stock_entry(
            item_code="_Test Item",
            target="_Test Warehouse - _TC",
            qty=returned_qty,
            purpose="Sales Return",
            sales_invoice_no=si.name,
        )

        # check if available qty is increased
        actual_qty_2 = get_qty_after_transaction()

        self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2)

        return se
def make_credit_note(docname):
	create_sales_invoice(company="_Test Company 2",
			customer = '_Test Customer 2',
			currency = 'EUR',
			qty = -1,
			warehouse = 'Finished Goods - _TC2',
			debit_to = 'Debtors - _TC2',
			income_account = 'Sales - _TC2',
			expense_account = 'Cost of Goods Sold - _TC2',
			cost_center = '_Test Company 2 - _TC2',
			is_return = 1,
			return_against = docname)
	def test_payment_against_negative_sales_invoice(self):
		pe1 = frappe.new_doc("Payment Entry")
		pe1.payment_type = "Pay"
		pe1.company = "_Test Company"
		pe1.party_type = "Customer"
		pe1.party = "_Test Customer"
		pe1.paid_from = "_Test Cash - _TC"
		pe1.paid_amount = 100
		pe1.received_amount = 100

		self.assertRaises(InvalidPaymentEntry, pe1.validate)

		si1 =  create_sales_invoice()

		# create full payment entry against si1
		pe2 = get_payment_entry("Sales Invoice", si1.name, bank_account="_Test Cash - _TC")
		pe2.insert()
		pe2.submit()

		# create return entry against si1
		create_sales_invoice(is_return=1, return_against=si1.name, qty=-1)
		si1_outstanding = frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount")
		self.assertEqual(si1_outstanding, -100)

		# pay more than outstanding against si1
		pe3 = get_payment_entry("Sales Invoice", si1.name, bank_account="_Test Cash - _TC")
		pe3.paid_amount = pe3.received_amount = 300
		self.assertRaises(InvalidPaymentEntry, pe3.validate)

		# pay negative outstanding against si1
		pe3.paid_to = "Debtors - _TC"
		pe3.paid_amount = pe3.received_amount = 100

		pe3.insert()
		pe3.submit()

		expected_gle = dict((d[0], d) for d in [
			["Debtors - _TC", 100, 0, si1.name],
			["_Test Cash - _TC", 0, 100, None]
		])

		self.validate_gl_entries(pe3.name, expected_gle)

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, 0)

		pe3.cancel()
		self.assertFalse(self.get_gle(pe3.name))

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si1.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, -100)
	def test_pos_closing_voucher(self):
		old_user = frappe.session.user
		user = '******'
		test_user = frappe.get_doc('User', user)

		roles = ("Accounts Manager", "Accounts User", "Sales Manager")
		test_user.add_roles(*roles)
		frappe.set_user(user)

		pos_profile = make_pos_profile()
		pos_profile.append('applicable_for_users', {
			'default': 1,
			'user': user
		})

		pos_profile.save()

		si1 = create_sales_invoice(is_pos=1, rate=3500, do_not_submit=1)
		si1.append('payments', {
			'mode_of_payment': 'Cash', 'account': 'Cash - _TC', 'amount': 3500
		})
		si1.submit()

		si2 = create_sales_invoice(is_pos=1, rate=3200, do_not_submit=1)
		si2.append('payments', {
			'mode_of_payment': 'Cash', 'account': 'Cash - _TC', 'amount': 3200
		})
		si2.submit()

		pcv_doc = create_pos_closing_voucher(user=user,
			pos_profile=pos_profile.name, collected_amount=6700)

		pcv_doc.get_closing_voucher_details()

		self.assertEqual(pcv_doc.total_quantity, 2)
		self.assertEqual(pcv_doc.net_total, 6700)

		payment = pcv_doc.payment_reconciliation[0]
		self.assertEqual(payment.mode_of_payment, 'Cash')

		si1.load_from_db()
		si1.cancel()

		si2.load_from_db()
		si2.cancel()

		test_user.load_from_db()
		test_user.remove_roles(*roles)

		frappe.set_user(old_user)
		frappe.db.sql("delete from `tabPOS Profile`")
	def test_payment_entry_write_off_difference(self):
		si =  create_sales_invoice()
		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC")
		pe.reference_no = "1"
		pe.reference_date = "2016-01-01"
		pe.received_amount = pe.paid_amount = 110
		pe.insert()

		self.assertEqual(pe.unallocated_amount, 10)

		pe.received_amount = pe.paid_amount = 95
		pe.append("deductions", {
			"account": "_Test Write Off - _TC",
			"cost_center": "_Test Cost Center - _TC",
			"amount": 5
		})
		pe.save()

		self.assertEqual(pe.unallocated_amount, 0)
		self.assertEqual(pe.difference_amount, 0)

		pe.submit()

		expected_gle = dict((d[0], d) for d in [
			["Debtors - _TC", 0, 100, si.name],
			["_Test Cash - _TC", 95, 0, None],
			["_Test Write Off - _TC", 5, 0, None]
		])

		self.validate_gl_entries(pe.name, expected_gle)
	def test_payment_entry_against_si_usd_to_inr(self):
		si =  create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
			currency="USD", conversion_rate=50)
		pe = get_payment_entry("Sales Invoice", si.name, party_amount=20,
			bank_account="_Test Bank - _TC", bank_amount=900)
		pe.reference_no = "1"
		pe.reference_date = "2016-01-01"

		self.assertEqual(pe.difference_amount, 100)

		pe.append("deductions", {
			"account": "_Test Exchange Gain/Loss - _TC",
			"cost_center": "_Test Cost Center - _TC",
			"amount": 100
		})
		pe.insert()
		pe.submit()

		expected_gle = dict((d[0], d) for d in [
			["_Test Receivable USD - _TC", 0, 1000, si.name],
			["_Test Bank - _TC", 900, 0, None],
			["_Test Exchange Gain/Loss - _TC", 100.0, 0, None],
		])

		self.validate_gl_entries(pe.name, expected_gle)

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, 80)
	def test_payment_entry_exchange_gain_loss(self):
		si =  create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
			currency="USD", conversion_rate=50)
		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC")
		pe.reference_no = "1"
		pe.reference_date = "2016-01-01"
		pe.target_exchange_rate = 55

		pe.append("deductions", {
			"account": "_Test Exchange Gain/Loss - _TC",
			"cost_center": "_Test Cost Center - _TC",
			"amount": -500
		})
		pe.save()

		self.assertEqual(pe.unallocated_amount, 0)
		self.assertEqual(pe.difference_amount, 0)

		pe.submit()

		expected_gle = dict((d[0], d) for d in [
			["_Test Receivable USD - _TC", 0, 5000, si.name],
			["_Test Bank USD - _TC", 5500, 0, None],
			["_Test Exchange Gain/Loss - _TC", 0, 500, None],
		])

		self.validate_gl_entries(pe.name, expected_gle)

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, 0)
	def test_payment_entry_against_si_usd_to_usd(self):
		si =  create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
			currency="USD", conversion_rate=50)
		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC")
		pe.reference_no = "1"
		pe.reference_date = "2016-01-01"
		pe.target_exchange_rate = 50
		pe.insert()
		pe.submit()

		expected_gle = dict((d[0], d) for d in [
			["_Test Receivable USD - _TC", 0, 5000, si.name],
			["_Test Bank USD - _TC", 5000.0, 0, None]
		])

		self.validate_gl_entries(pe.name, expected_gle)

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, 0)

		pe.cancel()
		self.assertFalse(self.get_gle(pe.name))

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, 100)
	def test_payment_entry(self):
		so_inr = make_sales_order(currency="INR")
		pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**",
			mute_email=1, submit_doc=1)
		jv = pr.set_as_paid()

		so_inr = frappe.get_doc("Sales Order", so_inr.name)

		self.assertEquals(so_inr.advance_paid, jv.total_debit)

		conversion_rate = get_exchange_rate("USD", "INR")

		si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
			currency="USD", conversion_rate=conversion_rate)

		pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**",
			mute_email=1, return_doc=1, payment_gateway="_Test Gateway - USD")

		jv = pr.set_as_paid()

		payment_gateway_details = get_gateway_details({"payment_gateway": "_Test Gateway - USD"})
				
		self.assertEquals(jv.accounts[0].account, "_Test Receivable USD - _TC")
		self.assertEquals(jv.accounts[1].account, payment_gateway_details.payment_account)
		
Beispiel #11
0
	def test_timesheet_billing_based_on_project(self):
		timesheet = make_timesheet("_T-Employee-0001", simulate=True, billable=1, project = '_Test Project', company='_Test Company')
		sales_invoice = create_sales_invoice(do_not_save=True)
		sales_invoice.project = '_Test Project'
		sales_invoice.submit()

		ts = frappe.get_doc('Timesheet', timesheet.name)
		self.assertEquals(ts.per_billed, 100)
		self.assertEquals(ts.time_logs[0].sales_invoice, sales_invoice.name)
Beispiel #12
0
	def test_pricing_rule_with_margin_and_discount(self):
		frappe.delete_doc_if_exists('Pricing Rule', '_Test Pricing Rule')
		make_pricing_rule(selling=1, margin_type="Percentage", margin_rate_or_amount=10, discount_percentage=10)
		si = create_sales_invoice(do_not_save=True)
		si.items[0].price_list_rate = 1000
		si.payment_schedule = []
		si.insert(ignore_permissions=True)

		item = si.items[0]
		self.assertEquals(item.margin_rate_or_amount, 10)
		self.assertEquals(item.rate_with_margin, 1100)
		self.assertEqual(item.discount_percentage, 10)
		self.assertEquals(item.discount_amount, 110)
		self.assertEquals(item.rate, 990)
	def test_payment_request_linkings(self):
		SO_INR = make_sales_order(currency="INR")
		pr = make_payment_request(dt="Sales Order", dn=SO_INR.name, recipient_id="*****@*****.**")
		
		self.assertEquals(pr.reference_doctype, "Sales Order")
		self.assertEquals(pr.reference_name, SO_INR.name)
		self.assertEquals(pr.currency, "INR")
		
		SI_USD = create_sales_invoice(currency="USD", conversion_rate=50)
		pr = make_payment_request(dt="Sales Invoice", dn=SI_USD.name, recipient_id="*****@*****.**")

		self.assertEquals(pr.reference_doctype, "Sales Invoice")
		self.assertEquals(pr.reference_name, SI_USD.name)
		self.assertEquals(pr.currency, "USD")
	def test_payment_request_linkings(self):
		so_inr = make_sales_order(currency="INR")
		pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**")

		self.assertEquals(pr.reference_doctype, "Sales Order")
		self.assertEquals(pr.reference_name, so_inr.name)
		self.assertEquals(pr.currency, "INR")

		conversion_rate = get_exchange_rate("USD", "INR")

		si_usd = create_sales_invoice(currency="USD", conversion_rate=conversion_rate)
		pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**")

		self.assertEquals(pr.reference_doctype, "Sales Invoice")
		self.assertEquals(pr.reference_name, si_usd.name)
		self.assertEquals(pr.currency, "USD")
	def test_payment_entry(self):
		SO_INR = make_sales_order(currency="INR")
		pr = make_payment_request(dt="Sales Order", dn=SO_INR.name, recipient_id="*****@*****.**", 
			mute_email=1, submit_doc=1)	 
		jv = pr.set_as_paid()
		
		SO_INR = frappe.get_doc("Sales Order", SO_INR.name)
		
		self.assertEquals(SO_INR.advance_paid, jv.total_debit)
		
		SI_USD = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
			currency="USD", conversion_rate=50)

		pr = make_payment_request(dt="Sales Invoice", dn=SI_USD.name, recipient_id="*****@*****.**",
			mute_email=1, return_doc=1, payemnt_gateway="_Test Gateway - USD")
		
		self.assertRaises(frappe.ValidationError, pr.save)
    def test_gl_entries_in_base_currency(self):
        inv = create_sales_invoice(rate=200)
        inv_disc = create_invoice_discounting(
            [inv.name],
            accounts_receivable_credit=self.ar_credit,
            accounts_receivable_discounted=self.ar_discounted,
            accounts_receivable_unpaid=self.ar_unpaid,
            short_term_loan=self.short_term_loan,
            bank_charges_account=self.bank_charges_account,
            bank_account=self.bank_account)

        gle = get_gl_entries("Invoice Discounting", inv_disc.name)

        expected_gle = {inv.debit_to: [0.0, 200], self.ar_credit: [200, 0.0]}
        for i, gle in enumerate(gle):
            self.assertEqual([gle.debit, gle.credit],
                             expected_gle.get(gle.account))
Beispiel #17
0
    def test_timesheet_billing_based_on_project(self):
        emp = make_employee("*****@*****.**")
        project = frappe.get_value("Project",
                                   {"project_name": "_Test Project"})

        timesheet = make_timesheet(emp,
                                   simulate=True,
                                   billable=1,
                                   project=project,
                                   company='_Test Company')
        sales_invoice = create_sales_invoice(do_not_save=True)
        sales_invoice.project = project
        sales_invoice.submit()

        ts = frappe.get_doc('Timesheet', timesheet.name)
        self.assertEqual(ts.per_billed, 100)
        self.assertEqual(ts.time_logs[0].sales_invoice, sales_invoice.name)
Beispiel #18
0
    def test_pricing_rule_with_margin_and_discount(self):
        frappe.delete_doc_if_exists('Pricing Rule', '_Test Pricing Rule')
        make_pricing_rule(selling=1,
                          margin_type="Percentage",
                          margin_rate_or_amount=10,
                          discount_percentage=10)
        si = create_sales_invoice(do_not_save=True)
        si.items[0].price_list_rate = 1000
        si.payment_schedule = []
        si.insert(ignore_permissions=True)

        item = si.items[0]
        self.assertEquals(item.margin_rate_or_amount, 10)
        self.assertEquals(item.rate_with_margin, 1100)
        self.assertEqual(item.discount_percentage, 10)
        self.assertEquals(item.discount_amount, 110)
        self.assertEquals(item.rate, 990)
	def test_pricing_rule_with_margin_and_discount(self):
		make_pricing_rule(selling=1, margin_type="Percentage", margin_rate_or_amount=10)
		si = create_sales_invoice(do_not_save=True)
		si.items[0].price_list_rate = 1000
		si.insert(ignore_permissions=True)

		item = si.items[0]
		self.assertEquals(item.rate, 1100)
		self.assertEquals(item.margin_rate_or_amount, 10)

		# With discount
		item.discount_percentage = 10
		si.save()
		item = si.items[0]
		self.assertEquals(item.rate, 990)
		self.assertEquals(item.discount_percentage, 10)
		frappe.db.sql("delete from `tabPricing Rule`")
    def test_on_disbursed(self):
        inv = create_sales_invoice(rate=500)
        inv_disc = create_invoice_discounting(
            [inv.name],
            accounts_receivable_credit=self.ar_credit,
            accounts_receivable_discounted=self.ar_discounted,
            accounts_receivable_unpaid=self.ar_unpaid,
            short_term_loan=self.short_term_loan,
            bank_charges_account=self.bank_charges_account,
            bank_account=self.bank_account,
            bank_charges=100,
        )

        je = inv_disc.create_disbursement_entry()

        self.assertEqual(je.accounts[0].account, self.bank_account)
        self.assertEqual(
            je.accounts[0].debit_in_account_currency,
            flt(inv_disc.total_amount) - flt(inv_disc.bank_charges),
        )

        self.assertEqual(je.accounts[1].account, self.bank_charges_account)
        self.assertEqual(je.accounts[1].debit_in_account_currency,
                         flt(inv_disc.bank_charges))

        self.assertEqual(je.accounts[2].account, self.short_term_loan)
        self.assertEqual(je.accounts[2].credit_in_account_currency,
                         flt(inv_disc.total_amount))

        self.assertEqual(je.accounts[3].account, self.ar_discounted)
        self.assertEqual(je.accounts[3].debit_in_account_currency,
                         flt(inv.outstanding_amount))

        self.assertEqual(je.accounts[4].account, self.ar_credit)
        self.assertEqual(je.accounts[4].credit_in_account_currency,
                         flt(inv.outstanding_amount))

        je.posting_date = nowdate()
        je.submit()

        inv_disc.reload()
        self.assertEqual(inv_disc.status, "Disbursed")

        inv.reload()
        self.assertEqual(inv.outstanding_amount, 500)
Beispiel #21
0
    def test_mandatory(self):
        si = create_sales_invoice(do_not_save=1)
        si.append(
            "items",
            {
                "item_code": "_Test Item",
                "warehouse": "_Test Warehouse - _TC",
                "qty": 1,
                "rate": 100,
                "income_account": "Sales - _TC",
                "expense_account": "Cost of Goods Sold - _TC",
                "cost_center": "_Test Cost Center - _TC",
                "location": "",
            },
        )

        si.save()
        self.assertRaises(frappe.ValidationError, si.submit)
Beispiel #22
0
	def test_payment_request_linkings(self):
		so_inr = make_sales_order(currency="INR")
		pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**",
			payment_gateway_account="_Test Gateway - INR")

		self.assertEqual(pr.reference_doctype, "Sales Order")
		self.assertEqual(pr.reference_name, so_inr.name)
		self.assertEqual(pr.currency, "INR")

		conversion_rate = get_exchange_rate("USD", "INR")

		si_usd = create_sales_invoice(currency="USD", conversion_rate=conversion_rate)
		pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**",
			payment_gateway_account="_Test Gateway - USD")

		self.assertEqual(pr.reference_doctype, "Sales Invoice")
		self.assertEqual(pr.reference_name, si_usd.name)
		self.assertEqual(pr.currency, "USD")
Beispiel #23
0
    def test_multiple_pricing_rules(self):
        make_pricing_rule(discount_percentage=20,
                          selling=1,
                          priority=1,
                          apply_multiple_pricing_rules=1,
                          title="_Test Pricing Rule 1")
        make_pricing_rule(discount_percentage=10,
                          selling=1,
                          title="_Test Pricing Rule 2",
                          priority=2,
                          apply_multiple_pricing_rules=1)
        si = create_sales_invoice(do_not_submit=True,
                                  customer="_Test Customer 1",
                                  qty=1)
        self.assertEqual(si.items[0].discount_percentage, 30)
        si.delete()

        frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 1")
        frappe.delete_doc_if_exists("Pricing Rule", "_Test Pricing Rule 2")
	def test_creation_of_ledger_entry_on_submit(self):
		"""test creation of gl entries on submission of document"""
		deferred_account = create_account(
			account_name="Deferred Revenue",
			parent_account="Current Liabilities - _TC",
			company="_Test Company",
		)

		item = create_item("_Test Item for Deferred Accounting")
		item.enable_deferred_revenue = 1
		item.deferred_revenue_account = deferred_account
		item.no_of_months = 12
		item.save()

		si = create_sales_invoice(
			item=item.name, update_stock=0, posting_date="2019-01-10", do_not_submit=True
		)
		si.items[0].enable_deferred_revenue = 1
		si.items[0].service_start_date = "2019-01-10"
		si.items[0].service_end_date = "2019-03-15"
		si.items[0].deferred_revenue_account = deferred_account
		si.save()
		si.submit()

		process_deferred_accounting = doc = frappe.get_doc(
			dict(
				doctype="Process Deferred Accounting",
				posting_date="2019-01-01",
				start_date="2019-01-01",
				end_date="2019-01-31",
				type="Income",
			)
		)

		process_deferred_accounting.insert()
		process_deferred_accounting.submit()

		expected_gle = [
			[deferred_account, 33.85, 0.0, "2019-01-31"],
			["Sales - _TC", 0.0, 33.85, "2019-01-31"],
		]

		check_gl_entries(self, si.name, expected_gle, "2019-01-10")
Beispiel #25
0
	def test_payment_against_sales_invoice_to_check_status(self):
		si = create_sales_invoice(customer="_Test Customer", debit_to="_Test Receivable - _TC",
			currency="INR")

		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")
		pe.reference_no = "1"
		pe.reference_date = "2016-01-01"
		pe.insert()
		pe.submit()

		outstanding_amount, status = frappe.db.get_value("Sales Invoice", si.name, ["outstanding_amount", "status"])
		self.assertEqual(flt(outstanding_amount), 0)
		self.assertEqual(status, 'Paid')

		pe.cancel()

		outstanding_amount, status = frappe.db.get_value("Sales Invoice", si.name, ["outstanding_amount", "status"])
		self.assertEqual(flt(outstanding_amount), 100)
		self.assertEqual(status, 'Unpaid')
Beispiel #26
0
    def test_return_against_sales_order(self):
        so = make_sales_order()

        dn = create_dn_against_so(so.name, 6)

        so.load_from_db()
        self.assertEqual(so.get("items")[0].delivered_qty, 6)

        # Check delivered_qty after make_sales_invoice with update_stock checked
        si2 = make_sales_invoice(so.name)
        si2.set("update_stock", 1)
        si2.get("items")[0].qty = 3
        si2.insert()
        si2.submit()

        so.load_from_db()

        self.assertEqual(so.get("items")[0].delivered_qty, 9)

        # Make return deliver note, sales invoice and check quantity
        from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
        from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice

        dn1 = create_delivery_note(is_return=1,
                                   return_against=dn.name,
                                   qty=-3,
                                   do_not_submit=True)
        dn1.items[0].against_sales_order = so.name
        dn1.items[0].so_detail = so.items[0].name
        dn1.submit()

        si1 = create_sales_invoice(is_return=1,
                                   return_against=si2.name,
                                   qty=-1,
                                   update_stock=1,
                                   do_not_submit=True)
        si1.items[0].sales_order = so.name
        si1.items[0].so_detail = so.items[0].name
        si1.submit()

        so.load_from_db()
        self.assertEqual(so.get("items")[0].delivered_qty, 5)
	def test_payment_entry(self):
		frappe.db.set_value("Company", "_Test Company", 
			"exchange_gain_loss_account", "_Test Exchange Gain/Loss - _TC")
		frappe.db.set_value("Company", "_Test Company", 
			"write_off_account", "_Test Write Off - _TC")
		frappe.db.set_value("Company", "_Test Company", 
			"cost_center", "_Test Cost Center - _TC")
		
		so_inr = make_sales_order(currency="INR")
		pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**",
			mute_email=1, submit_doc=1)
		pe = pr.set_as_paid()

		so_inr = frappe.get_doc("Sales Order", so_inr.name)

		self.assertEquals(so_inr.advance_paid, 1000)

		si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
			currency="USD", conversion_rate=50)

		pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**",
			mute_email=1, payment_gateway="_Test Gateway - USD", submit_doc=1)
		
		pe = pr.set_as_paid()
		
		expected_gle = dict((d[0], d) for d in [
			["_Test Receivable USD - _TC", 0, 5000, si_usd.name],
			[pr.payment_account, 6000.0, 0, None],
			["_Test Exchange Gain/Loss - _TC", 0, 1000, None]
		])
		
		gl_entries = frappe.db.sql("""select account, debit, credit, against_voucher
			from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
			order by account asc""", pe.name, as_dict=1)

		self.assertTrue(gl_entries)

		for i, gle in enumerate(gl_entries):
			self.assertEquals(expected_gle[gle.account][0], gle.account)
			self.assertEquals(expected_gle[gle.account][1], gle.debit)
			self.assertEquals(expected_gle[gle.account][2], gle.credit)
			self.assertEquals(expected_gle[gle.account][3], gle.against_voucher)
Beispiel #28
0
def make_sales_invoice():
	frappe.set_user("Administrator")

	si = create_sales_invoice(company="_Test Company 2",
			customer = '_Test Customer 2',
			currency = 'EUR',
			warehouse = 'Finished Goods - _TC2',
			debit_to = 'Debtors - _TC2',
			income_account = 'Sales - _TC2',
			expense_account = 'Cost of Goods Sold - _TC2',
			cost_center = '_Test Company 2 - _TC2',
			do_not_save=1)

	si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30))
	si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50))
	si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20))

	si.submit()

	return si.name
    def test_on_close_after_loan_period(self):
        inv = create_sales_invoice(rate=600)
        inv_disc = create_invoice_discounting(
            [inv.name],
            accounts_receivable_credit=self.ar_credit,
            accounts_receivable_discounted=self.ar_discounted,
            accounts_receivable_unpaid=self.ar_unpaid,
            short_term_loan=self.short_term_loan,
            bank_charges_account=self.bank_charges_account,
            bank_account=self.bank_account,
            start=nowdate(),
            period=60,
        )

        je1 = inv_disc.create_disbursement_entry()
        je1.posting_date = nowdate()
        je1.submit()

        je2 = inv_disc.close_loan()

        self.assertEqual(je2.accounts[0].account, self.short_term_loan)
        self.assertEqual(je2.accounts[0].debit_in_account_currency,
                         flt(inv_disc.total_amount))

        self.assertEqual(je2.accounts[1].account, self.bank_account)
        self.assertEqual(je2.accounts[1].credit_in_account_currency,
                         flt(inv_disc.total_amount))

        self.assertEqual(je2.accounts[2].account, self.ar_discounted)
        self.assertEqual(je2.accounts[2].credit_in_account_currency,
                         flt(inv.outstanding_amount))

        self.assertEqual(je2.accounts[3].account, self.ar_unpaid)
        self.assertEqual(je2.accounts[3].debit_in_account_currency,
                         flt(inv.outstanding_amount))

        je2.posting_date = nowdate()
        je2.submit()
        inv_disc.reload()

        self.assertEqual(inv_disc.status, "Settled")
Beispiel #30
0
	def test_payment_entry(self):
		frappe.db.set_value("Company", "_Test Company",
			"exchange_gain_loss_account", "_Test Exchange Gain/Loss - _TC")
		frappe.db.set_value("Company", "_Test Company", "write_off_account", "_Test Write Off - _TC")
		frappe.db.set_value("Company", "_Test Company", "cost_center", "_Test Cost Center - _TC")

		so_inr = make_sales_order(currency="INR")
		pr = make_payment_request(dt="Sales Order", dn=so_inr.name, recipient_id="*****@*****.**",
			mute_email=1, payment_gateway_account="_Test Gateway - INR", submit_doc=1, return_doc=1)
		pe = pr.set_as_paid()

		so_inr = frappe.get_doc("Sales Order", so_inr.name)

		self.assertEqual(so_inr.advance_paid, 1000)

		si_usd = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
			currency="USD", conversion_rate=50)

		pr = make_payment_request(dt="Sales Invoice", dn=si_usd.name, recipient_id="*****@*****.**",
			mute_email=1, payment_gateway_account="_Test Gateway - USD", submit_doc=1, return_doc=1)

		pe = pr.set_as_paid()

		expected_gle = dict((d[0], d) for d in [
			["_Test Receivable USD - _TC", 0, 5000, si_usd.name],
			[pr.payment_account, 6290.0, 0, None],
			["_Test Exchange Gain/Loss - _TC", 0, 1290, None]
		])

		gl_entries = frappe.db.sql("""select account, debit, credit, against_voucher
			from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
			order by account asc""", pe.name, as_dict=1)

		self.assertTrue(gl_entries)

		for i, gle in enumerate(gl_entries):
			self.assertEqual(expected_gle[gle.account][0], gle.account)
			self.assertEqual(expected_gle[gle.account][1], gle.debit)
			self.assertEqual(expected_gle[gle.account][2], gle.credit)
			self.assertEqual(expected_gle[gle.account][3], gle.against_voucher)
Beispiel #31
0
    def test_make_payment_before_after_period(self):
        #it has problem
        inv = create_sales_invoice(item_code="_Test Item Home Desktop 100",
                                   rate=700)
        inv_disc = create_invoice_discounting(
            [inv.name],
            accounts_receivable_credit=self.ar_credit,
            accounts_receivable_discounted=self.ar_discounted,
            accounts_receivable_unpaid=self.ar_unpaid,
            short_term_loan=self.short_term_loan,
            bank_charges_account=self.bank_charges_account,
            bank_account=self.bank_account,
            loan_start_date=add_days(nowdate(), -10),
            period=5)
        je = inv_disc.create_disbursement_entry()
        inv_disc.reload()
        je.posting_date = nowdate()
        je.submit()

        je = inv_disc.close_loan()
        inv_disc.reload()
        je.posting_date = nowdate()
        je.submit()

        je_on_payment = frappe.get_doc(
            get_payment_entry_against_invoice("Sales Invoice", inv.name))
        je_on_payment.posting_date = nowdate()
        je_on_payment.cheque_no = "126981"
        je_on_payment.cheque_date = nowdate()
        je_on_payment.submit()

        self.assertEqual(je_on_payment.accounts[0].account, self.ar_unpaid)
        self.assertEqual(je_on_payment.accounts[0].credit_in_account_currency,
                         flt(inv.outstanding_amount))
        self.assertEqual(je_on_payment.accounts[1].account, self.bank_account)
        self.assertEqual(je_on_payment.accounts[1].debit_in_account_currency,
                         flt(inv.outstanding_amount))

        inv.reload()
        self.assertEqual(inv.outstanding_amount, 0)
Beispiel #32
0
	def test_dimension_against_sales_invoice(self):
		si = create_sales_invoice(do_not_save=1)

		si.location = "Block 1"
		si.append("items", {
			"item_code": "_Test Item",
			"warehouse": "_Test Warehouse - _TC",
			"qty": 1,
			"rate": 100,
			"income_account": "Sales - _TC",
			"expense_account": "Cost of Goods Sold - _TC",
			"cost_center": "_Test Cost Center - _TC",
			"department": "_Test Department - _TC",
			"location": "Block 1"
		})

		si.save()
		si.submit()

		gle = frappe.get_doc("GL Entry", {"voucher_no": si.name, "account": "Sales - _TC"})

		self.assertEqual(gle.get('department'), "_Test Department - _TC")
Beispiel #33
0
	def test_payment_entry_exchange_gain_loss(self):
		si = create_sales_invoice(customer="_Test Customer", debit_to="_Test Receivable - _TC",
			currency="INR")
		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")
		pe.reference_no = "1"
		pe.reference_date = "2016-01-01"
		pe.save()

		self.assertEqual(pe.unallocated_amount, 0)
		self.assertEqual(pe.difference_amount, 0)

		pe.submit()

		expected_gle = dict((d[0], d) for d in [
			["_Test Receivable - _TC", 0, 100, si.name],
			["_Test Bank - _TC", 100, 0, None]
		])

		self.validate_gl_entries(pe.name, expected_gle)

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, 0)
Beispiel #34
0
    def test_gst_rounding(self):
        gst_settings = frappe.get_doc("GST Settings")
        gst_settings.round_off_gst_values = 1
        gst_settings.save()

        current_country = frappe.flags.country
        frappe.flags.country = "India"

        si = create_sales_invoice(
            company="_Test Company GST",
            customer="_Test GST Customer",
            currency="INR",
            warehouse="Finished Goods - _GST",
            debit_to="Debtors - _GST",
            income_account="Sales - _GST",
            expense_account="Cost of Goods Sold - _GST",
            cost_center="Main - _GST",
            rate=216,
            do_not_save=1,
        )

        si.append(
            "taxes",
            {
                "charge_type": "On Net Total",
                "account_head": "Output Tax IGST - _GST",
                "cost_center": "Main - _GST",
                "description": "IGST @ 18.0",
                "rate": 18,
            },
        )

        si.save()
        # Check for 39 instead of 38.88
        self.assertEqual(si.taxes[0].base_tax_amount_after_discount_amount, 39)

        frappe.flags.country = current_country
        gst_settings.round_off_gst_values = 1
        gst_settings.save()
Beispiel #35
0
    def test_remove_pricing_rule(self):
        item = make_item("Water Flask")
        make_item_price("Water Flask", "_Test Price List", 100)

        pricing_rule_record = {
            "doctype": "Pricing Rule",
            "title": "_Test Water Flask Rule",
            "apply_on": "Item Code",
            "price_or_product_discount": "Price",
            "items": [{
                "item_code": "Water Flask",
            }],
            "selling": 1,
            "currency": "INR",
            "rate_or_discount": "Discount Percentage",
            "discount_percentage": 20,
            "company": "_Test Company",
        }
        rule = frappe.get_doc(pricing_rule_record)
        rule.insert()

        si = create_sales_invoice(do_not_save=True, item_code="Water Flask")
        si.selling_price_list = "_Test Price List"
        si.save()

        self.assertEqual(si.items[0].price_list_rate, 100)
        self.assertEqual(si.items[0].discount_percentage, 20)
        self.assertEqual(si.items[0].rate, 80)

        si.ignore_pricing_rule = 1
        si.save()

        self.assertEqual(si.items[0].discount_percentage, 0)
        self.assertEqual(si.items[0].rate, 100)

        si.delete()
        rule.delete()
        frappe.get_doc("Item Price", {"item_code": "Water Flask"}).delete()
        item.delete()
Beispiel #36
0
    def test_customer_credit_limit(self):
        from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
        from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
        from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
        from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice

        outstanding_amt = self.get_customer_outstanding_amount()
        credit_limit = get_credit_limit('_Test Customer', '_Test Company')

        if outstanding_amt <= 0.0:
            item_qty = int((abs(outstanding_amt) + 200) / 100)
            make_sales_order(qty=item_qty)

        if credit_limit == 0.0:
            frappe.db.set_value("Customer", '_Test Customer', 'credit_limit',
                                outstanding_amt - 50.0)

        # Sales Order
        so = make_sales_order(do_not_submit=True)
        self.assertRaises(frappe.ValidationError, so.submit)

        # Delivery Note
        dn = create_delivery_note(do_not_submit=True)
        self.assertRaises(frappe.ValidationError, dn.submit)

        # Sales Invoice
        si = create_sales_invoice(do_not_submit=True)
        self.assertRaises(frappe.ValidationError, si.submit)

        if credit_limit > outstanding_amt:
            frappe.db.set_value("Customer", '_Test Customer', 'credit_limit',
                                credit_limit)

        # Makes Sales invoice from Sales Order
        so.save(ignore_permissions=True)
        si = make_sales_invoice(so.name)
        si.save(ignore_permissions=True)
        self.assertRaises(frappe.ValidationError, make_sales_order)
Beispiel #37
0
    def test_status(self):
        si_usd = create_sales_invoice(customer="_Test Customer USD",
                                      debit_to="_Test Receivable USD - _TC",
                                      currency="USD",
                                      conversion_rate=50)

        pr = make_payment_request(dt="Sales Invoice",
                                  dn=si_usd.name,
                                  recipient_id="*****@*****.**",
                                  mute_email=1,
                                  payment_gateway="_Test Gateway - USD",
                                  submit_doc=1,
                                  return_doc=1)

        pe = pr.create_payment_entry()
        pr.load_from_db()

        self.assertEqual(pr.status, 'Paid')

        pe.cancel()
        pr.load_from_db()

        self.assertEqual(pr.status, 'Requested')
Beispiel #38
0
    def test_payment_entry_exchange_gain_loss(self):
        si = create_sales_invoice(customer="_Test Customer USD",
                                  debit_to="_Test Receivable USD - _TC",
                                  currency="USD",
                                  conversion_rate=50)
        pe = get_payment_entry("Sales Invoice",
                               si.name,
                               bank_account="_Test Bank USD - _TC")
        pe.reference_no = "1"
        pe.reference_date = "2016-01-01"
        pe.target_exchange_rate = 55

        pe.append(
            "deductions", {
                "account": "_Test Exchange Gain/Loss - _TC",
                "cost_center": "_Test Cost Center - _TC",
                "amount": -500
            })
        pe.save()

        self.assertEqual(pe.unallocated_amount, 0)
        self.assertEqual(pe.difference_amount, 0)

        pe.submit()

        expected_gle = dict((d[0], d) for d in [
            ["_Test Receivable USD - _TC", 0, 5000, si.name],
            ["_Test Bank USD - _TC", 5500, 0, None],
            ["_Test Exchange Gain/Loss - _TC", 0, 500, None],
        ])

        self.validate_gl_entries(pe.name, expected_gle)

        outstanding_amount = flt(
            frappe.db.get_value("Sales Invoice", si.name,
                                "outstanding_amount"))
        self.assertEqual(outstanding_amount, 0)
Beispiel #39
0
	def test_payment_entry_against_payment_terms(self):
		si = create_sales_invoice(do_not_save=1, qty=1, rate=200)
		create_payment_terms_template()
		si.payment_terms_template = 'Test Receivable Template'

		si.append('taxes', {
			"charge_type": "On Net Total",
			"account_head": "_Test Account Service Tax - _TC",
			"cost_center": "_Test Cost Center - _TC",
			"description": "Service Tax",
			"rate": 18
		})
		si.save()

		si.submit()

		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Cash - _TC")
		pe.submit()
		si.load_from_db()

		self.assertEqual(pe.references[0].payment_term, 'Basic Amount Receivable')
		self.assertEqual(pe.references[1].payment_term, 'Tax Receivable')
		self.assertEqual(si.payment_schedule[0].paid_amount, 200.0)
		self.assertEqual(si.payment_schedule[1].paid_amount, 36.0)
Beispiel #40
0
	def test_payment_entry_against_sales_invoice_for_disable_allow_cost_center_in_entry_of_bs_account(self):
		accounts_settings = frappe.get_doc('Accounts Settings', 'Accounts Settings')
		accounts_settings.allow_cost_center_in_entry_of_bs_account = 0
		accounts_settings.save()
		si =  create_sales_invoice(debit_to="Debtors - _TC")

		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")

		pe.reference_no = "112211-2"
		pe.reference_date = nowdate()
		pe.paid_to = "_Test Bank - _TC"
		pe.paid_amount = si.grand_total
		pe.insert()
		pe.submit()

		gl_entries = frappe.db.sql("""select account, cost_center, account_currency, debit, credit,
			debit_in_account_currency, credit_in_account_currency
			from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
			order by account asc""", pe.name, as_dict=1)

		self.assertTrue(gl_entries)

		for gle in gl_entries:
			self.assertEqual(gle.cost_center, None)
Beispiel #41
0
	def test_customer_credit_limit(self):
		from erpnext.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
		from erpnext.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice
		from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
		from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice

		outstanding_amt = self.get_customer_outstanding_amount()
		credit_limit = get_credit_limit('_Test Customer', '_Test Company')

		if outstanding_amt <= 0.0:
			item_qty = int((abs(outstanding_amt) + 200)/100)
			make_sales_order(qty=item_qty)

		if credit_limit == 0.0:
			frappe.db.set_value("Customer", '_Test Customer', 'credit_limit', outstanding_amt - 50.0)

		# Sales Order
		so = make_sales_order(do_not_submit=True)
		self.assertRaises(frappe.ValidationError, so.submit)

		# Delivery Note
		dn = create_delivery_note(do_not_submit=True)
		self.assertRaises(frappe.ValidationError, dn.submit)

		# Sales Invoice
		si = create_sales_invoice(do_not_submit=True)
		self.assertRaises(frappe.ValidationError, si.submit)

		if credit_limit > outstanding_amt:
			frappe.db.set_value("Customer", '_Test Customer', 'credit_limit', credit_limit)

		# Makes Sales invoice from Sales Order
		so.save(ignore_permissions=True)
		si = make_sales_invoice(so.name)
		si.save(ignore_permissions=True)
		self.assertRaises(frappe.ValidationError, make_sales_order)
Beispiel #42
0
	def test_payment_entry_against_si_usd_to_usd(self):
		si = create_sales_invoice(customer="_Test Customer USD", debit_to="_Test Receivable USD - _TC",
			currency="USD", conversion_rate=50)
		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank USD - _TC")
		pe.reference_no = "1"
		pe.reference_date = "2016-01-01"
		pe.target_exchange_rate = 50
		pe.insert()
		pe.submit()

		expected_gle = dict((d[0], d) for d in [
			["_Test Receivable USD - _TC", 0, 5000, si.name],
			["_Test Bank USD - _TC", 5000.0, 0, None]
		])

		self.validate_gl_entries(pe.name, expected_gle)

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, 0)

		pe.cancel()

		outstanding_amount = flt(frappe.db.get_value("Sales Invoice", si.name, "outstanding_amount"))
		self.assertEqual(outstanding_amount, 100)
Beispiel #43
0
    def test_payment_entry_against_si_usd_to_inr(self):
        si = create_sales_invoice(customer="_Test Customer USD",
                                  debit_to="_Test Receivable USD - _TC",
                                  currency="USD",
                                  conversion_rate=50)
        pe = get_payment_entry("Sales Invoice",
                               si.name,
                               party_amount=20,
                               bank_account="_Test Bank - _TC",
                               bank_amount=900)
        pe.reference_no = "1"
        pe.reference_date = "2016-01-01"

        self.assertEqual(pe.difference_amount, 100)

        pe.append(
            "deductions", {
                "account": "_Test Exchange Gain/Loss - _TC",
                "cost_center": "_Test Cost Center - _TC",
                "amount": 100
            })
        pe.insert()
        pe.submit()

        expected_gle = dict((d[0], d) for d in [
            ["_Test Receivable USD - _TC", 0, 1000, si.name],
            ["_Test Bank - _TC", 900, 0, None],
            ["_Test Exchange Gain/Loss - _TC", 100.0, 0, None],
        ])

        self.validate_gl_entries(pe.name, expected_gle)

        outstanding_amount = flt(
            frappe.db.get_value("Sales Invoice", si.name,
                                "outstanding_amount"))
        self.assertEqual(outstanding_amount, 80)
Beispiel #44
0
	def test_item_price_with_pricing_rule(self):
		item = make_item("Water Flask")
		make_item_price("Water Flask", "_Test Price List", 100)

		pricing_rule_record = {
			"doctype": "Pricing Rule",
			"title": "_Test Water Flask Rule",
			"apply_on": "Item Code",
			"items": [{
				"item_code": "Water Flask",
			}],
			"selling": 1,
			"currency": "INR",
			"rate_or_discount": "Rate",
			"rate": 0,
			"margin_type": "Percentage",
			"margin_rate_or_amount": 2,
			"company": "_Test Company"
		}
		rule = frappe.get_doc(pricing_rule_record)
		rule.insert()

		si = create_sales_invoice(do_not_save=True, item_code="Water Flask")
		si.selling_price_list = "_Test Price List"
		si.save()

		# If rate in Rule is 0, give preference to Item Price if it exists
		self.assertEqual(si.items[0].price_list_rate, 100)
		self.assertEqual(si.items[0].margin_rate_or_amount, 2)
		self.assertEqual(si.items[0].rate_with_margin, 102)
		self.assertEqual(si.items[0].rate, 102)

		si.delete()
		rule.delete()
		frappe.get_doc("Item Price", {"item_code": "Water Flask"}).delete()
		item.delete()
Beispiel #45
0
	def test_payment_entry_against_sales_invoice_for_disable_allow_cost_center_in_entry_of_bs_account(self):
		accounts_settings = frappe.get_doc('Accounts Settings', 'Accounts Settings')
		accounts_settings.allow_cost_center_in_entry_of_bs_account = 0
		accounts_settings.save()
		si =  create_sales_invoice(debit_to="Debtors - _TC")

		pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")

		pe.reference_no = "112211-2"
		pe.reference_date = nowdate()
		pe.paid_to = "_Test Bank - _TC"
		pe.paid_amount = si.grand_total
		pe.insert()
		pe.submit()

		gl_entries = frappe.db.sql("""select account, cost_center, account_currency, debit, credit,
			debit_in_account_currency, credit_in_account_currency
			from `tabGL Entry` where voucher_type='Payment Entry' and voucher_no=%s
			order by account asc""", pe.name, as_dict=1)

		self.assertTrue(gl_entries)

		for gle in gl_entries:
			self.assertEqual(gle.cost_center, None)
Beispiel #46
0
def add_vouchers():
	if frappe.flags.test_payments_created:
		return

	frappe.set_user("Administrator")

	try:
		frappe.get_doc({
			"doctype": "Supplier",
			"supplier_group":"All Supplier Groups",
			"supplier_type": "Company",
			"supplier_name": "Conrad Electronic"
		}).insert()

	except frappe.DuplicateEntryError:
		pass

	pi = make_purchase_invoice(supplier="Conrad Electronic", qty=1, rate=690)

	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Conrad Oct 18"
	pe.reference_date = "2018-10-24"
	pe.insert()
	pe.submit()

	try:
		frappe.get_doc({
			"doctype": "Supplier",
			"supplier_group":"All Supplier Groups",
			"supplier_type": "Company",
			"supplier_name": "Mr G"
		}).insert()
	except frappe.DuplicateEntryError:
		pass

	pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1200)
	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Herr G Oct 18"
	pe.reference_date = "2018-10-24"
	pe.insert()
	pe.submit()

	pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1700)
	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Herr G Nov 18"
	pe.reference_date = "2018-11-01"
	pe.insert()
	pe.submit()

	try:
		frappe.get_doc({
			"doctype": "Supplier",
			"supplier_group":"All Supplier Groups",
			"supplier_type": "Company",
			"supplier_name": "Poore Simon's"
		}).insert()
	except frappe.DuplicateEntryError:
		pass

	try:
		frappe.get_doc({
			"doctype": "Customer",
			"customer_group":"All Customer Groups",
			"customer_type": "Company",
			"customer_name": "Poore Simon's"
		}).insert()
	except frappe.DuplicateEntryError:
		pass

	pi = make_purchase_invoice(supplier="Poore Simon's", qty=1, rate=3900, is_paid=1, do_not_save =1)
	pi.cash_bank_account = "_Test Bank - _TC"
	pi.insert()
	pi.submit()
	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Poore Simon's Oct 18"
	pe.reference_date = "2018-10-28"
	pe.paid_amount = 690
	pe.received_amount = 690
	pe.insert()
	pe.submit()

	si = create_sales_invoice(customer="Poore Simon's", qty=1, rate=3900)
	pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Poore Simon's Oct 18"
	pe.reference_date = "2018-10-28"
	pe.insert()
	pe.submit()

	try:
		frappe.get_doc({
			"doctype": "Customer",
			"customer_group":"All Customer Groups",
			"customer_type": "Company",
			"customer_name": "Fayva"
		}).insert()
	except frappe.DuplicateEntryError:
		pass

	si = create_sales_invoice(customer="Fayva", qty=1, rate=109080)
	pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Fayva Oct 18"
	pe.reference_date = "2018-10-29"
	pe.insert()
	pe.submit()

	mode_of_payment = frappe.get_doc({
		"doctype": "Mode of Payment",
		"name": "Cash"
	})

	if not frappe.db.get_value('Mode of Payment Account', {'company': "_Test Company", 'parent': "Cash"}):
		mode_of_payment.append("accounts", {
			"company": "_Test Company",
			"default_account": "_Test Bank - _TC"
		})
		mode_of_payment.save()

	si = create_sales_invoice(customer="Fayva", qty=1, rate=109080, do_not_submit=1)
	si.is_pos = 1
	si.append("payments", {
		"mode_of_payment": "Cash",
		"account": "_Test Bank - _TC",
		"amount": 109080
	})
	si.save()
	si.submit()

	frappe.flags.test_payments_created = True
    def test_deferred_revenue(self):
        self.clear_old_entries()

        # created deferred expense accounts, if not found
        deferred_revenue_account = create_account(
            account_name="Deferred Revenue",
            parent_account="Current Liabilities - _CD",
            company="_Test Company DR",
        )

        acc_settings = frappe.get_doc("Accounts Settings", "Accounts Settings")
        acc_settings.book_deferred_entries_based_on = "Months"
        acc_settings.save()

        customer = frappe.new_doc("Customer")
        customer.customer_name = "_Test Customer DR"
        customer.type = "Individual"
        customer.insert()

        item = create_item(
            "_Test Internet Subscription",
            is_stock_item=0,
            warehouse="All Warehouses - _CD",
            company="_Test Company DR",
        )
        item.enable_deferred_revenue = 1
        item.deferred_revenue_account = deferred_revenue_account
        item.no_of_months = 3
        item.save()

        si = create_sales_invoice(
            item=item.name,
            company="_Test Company DR",
            customer="_Test Customer DR",
            debit_to="Debtors - _CD",
            posting_date="2021-05-01",
            parent_cost_center="Main - _CD",
            cost_center="Main - _CD",
            do_not_save=True,
            rate=300,
            price_list_rate=300,
        )

        si.items[0].income_account = "Sales - _CD"
        si.items[0].enable_deferred_revenue = 1
        si.items[0].service_start_date = "2021-05-01"
        si.items[0].service_end_date = "2021-08-01"
        si.items[0].deferred_revenue_account = deferred_revenue_account
        si.items[0].income_account = "Sales - _CD"
        si.save()
        si.submit()

        pda = frappe.get_doc(
            dict(
                doctype="Process Deferred Accounting",
                posting_date=nowdate(),
                start_date="2021-05-01",
                end_date="2021-08-01",
                type="Income",
                company="_Test Company DR",
            ))
        pda.insert()
        pda.submit()

        # execute report
        fiscal_year = frappe.get_doc(
            "Fiscal Year", frappe.defaults.get_user_default("fiscal_year"))
        self.filters = frappe._dict({
            "company":
            frappe.defaults.get_user_default("Company"),
            "filter_based_on":
            "Date Range",
            "period_start_date":
            "2021-05-01",
            "period_end_date":
            "2021-08-01",
            "from_fiscal_year":
            fiscal_year.year,
            "to_fiscal_year":
            fiscal_year.year,
            "periodicity":
            "Monthly",
            "type":
            "Revenue",
            "with_upcoming_postings":
            False,
        })

        report = Deferred_Revenue_and_Expense_Report(filters=self.filters)
        report.run()
        expected = [
            {
                "key": "may_2021",
                "total": 100.0,
                "actual": 100.0
            },
            {
                "key": "jun_2021",
                "total": 100.0,
                "actual": 100.0
            },
            {
                "key": "jul_2021",
                "total": 100.0,
                "actual": 100.0
            },
            {
                "key": "aug_2021",
                "total": 0,
                "actual": 0
            },
        ]
        self.assertEqual(report.period_total, expected)
Beispiel #48
0
def make_sales_invoice():
	si = create_sales_invoice(company="_Test Company GST",
			customer = '_Test GST Customer',
			currency = 'INR',
			warehouse = 'Finished Goods - _GST',
			debit_to = 'Debtors - _GST',
			income_account = 'Sales - _GST',
			expense_account = 'Cost of Goods Sold - _GST',
			cost_center = 'Main - _GST',
			posting_date = '2019-03-10',
			do_not_save=1
		)

	si.append("taxes", {
			"charge_type": "On Net Total",
			"account_head": "IGST - _GST",
			"cost_center": "Main - _GST",
			"description": "IGST @ 18.0",
			"rate": 18
		})

	si.submit()

	si1 = create_sales_invoice(company="_Test Company GST",
			customer = '_Test GST SEZ Customer',
			currency = 'INR',
			warehouse = 'Finished Goods - _GST',
			debit_to = 'Debtors - _GST',
			income_account = 'Sales - _GST',
			expense_account = 'Cost of Goods Sold - _GST',
			cost_center = 'Main - _GST',
			posting_date = '2019-03-10',
			do_not_save=1
		)

	si1.append("taxes", {
			"charge_type": "On Net Total",
			"account_head": "IGST - _GST",
			"cost_center": "Main - _GST",
			"description": "IGST @ 18.0",
			"rate": 18
		})

	si1.submit()

	si2 = create_sales_invoice(company="_Test Company GST",
			customer = '_Test Unregistered Customer',
			currency = 'INR',
			warehouse = 'Finished Goods - _GST',
			debit_to = 'Debtors - _GST',
			income_account = 'Sales - _GST',
			expense_account = 'Cost of Goods Sold - _GST',
			cost_center = 'Main - _GST',
			posting_date = '2019-03-10',
			do_not_save=1
		)

	si2.append("taxes", {
			"charge_type": "On Net Total",
			"account_head": "IGST - _GST",
			"cost_center": "Main - _GST",
			"description": "IGST @ 18.0",
			"rate": 18
		})

	si2.submit()

	si3 = create_sales_invoice(company="_Test Company GST",
			customer = '_Test GST Customer',
			currency = 'INR',
			item = 'Milk',
			warehouse = 'Finished Goods - _GST',
			debit_to = 'Debtors - _GST',
			income_account = 'Sales - _GST',
			expense_account = 'Cost of Goods Sold - _GST',
			cost_center = 'Main - _GST',
			posting_date = '2019-03-10',
			do_not_save=1
		)
	si3.submit()
Beispiel #49
0
def add_payments():
	if frappe.flags.test_payments_created:
		return

	frappe.set_user("Administrator")

	try:
		frappe.get_doc({
			"doctype": "Supplier",
			"supplier_group":"All Supplier Groups",
			"supplier_type": "Company",
			"supplier_name": "Conrad Electronic"
		}).insert()

	except frappe.DuplicateEntryError:
		pass

	pi = make_purchase_invoice(supplier="Conrad Electronic", qty=1, rate=690)
	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Conrad Oct 18"
	pe.reference_date = "2018-10-24"
	pe.insert()
	pe.submit()

	try:
		frappe.get_doc({
			"doctype": "Supplier",
			"supplier_group":"All Supplier Groups",
			"supplier_type": "Company",
			"supplier_name": "Mr G"
		}).insert()
	except frappe.DuplicateEntryError:
		pass

	pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1200)
	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Herr G Oct 18"
	pe.reference_date = "2018-10-24"
	pe.insert()
	pe.submit()

	pi = make_purchase_invoice(supplier="Mr G", qty=1, rate=1700)
	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Herr G Nov 18"
	pe.reference_date = "2018-11-01"
	pe.insert()
	pe.submit()

	try:
		frappe.get_doc({
			"doctype": "Supplier",
			"supplier_group":"All Supplier Groups",
			"supplier_type": "Company",
			"supplier_name": "Poore Simon's"
		}).insert()
	except frappe.DuplicateEntryError:
		pass

	try:
		frappe.get_doc({
			"doctype": "Customer",
			"customer_group":"All Customer Groups",
			"customer_type": "Company",
			"customer_name": "Poore Simon's"
		}).insert()
	except frappe.DuplicateEntryError:
		pass

	pi = make_purchase_invoice(supplier="Poore Simon's", qty=1, rate=3900)
	pe = get_payment_entry("Purchase Invoice", pi.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Poore Simon's Oct 18"
	pe.reference_date = "2018-10-28"
	pe.insert()
	pe.submit()

	si = create_sales_invoice(customer="Poore Simon's", qty=1, rate=3900)
	pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Poore Simon's Oct 18"
	pe.reference_date = "2018-10-28"
	pe.insert()
	pe.submit()

	try:
		frappe.get_doc({
			"doctype": "Customer",
			"customer_group":"All Customer Groups",
			"customer_type": "Company",
			"customer_name": "Fayva"
		}).insert()
	except frappe.DuplicateEntryError:
		pass

	si = create_sales_invoice(customer="Fayva", qty=1, rate=109080)
	pe = get_payment_entry("Sales Invoice", si.name, bank_account="_Test Bank - _TC")
	pe.reference_no = "Fayva Oct 18"
	pe.reference_date = "2018-10-29"
	pe.insert()
	pe.submit()

	company = frappe.db.get_single_value('Global Defaults', 'default_company')
	frappe.get_doc({
		"doctype": "Mode of Payment",
		"name": "Cash"
	}).append("accounts", {
		"company": company,
		"default_account": "_Test Bank - _TC"
	}).save()
	si = create_sales_invoice(customer="Fayva", qty=1, rate=109080, do_not_submit=1)
	si.is_pos = 1
	si.append("payments", {
		"mode_of_payment": "Cash",
		"account": "_Test Bank - _TC",
		"amount": 109080
	})
	si.save()
	si.submit()

	frappe.flags.test_payments_created = True
Beispiel #50
0
    def test_accounting_period(self):
        ap1 = create_accounting_period(period_name = "Test Accounting Period 2")
        ap1.save()

        doc = create_sales_invoice(do_not_submit=1, cost_center = "_Test Company - _TC", warehouse = "Stores - _TC")
        self.assertRaises(ClosedAccountingPeriod, doc.submit)