[Neuclear-develop] neuclear-pay/src/test/org/neuclear/asset/controllers/currency IssuanceTests.java,NONE,1.1 CurrencyTests.java,1.8,1.9

[Pelle B. <pe...@us...>]

Update of /cvsroot/neuclear/neuclear-pay/src/test/org/neuclear/asset/controllers/currency
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv20268/src/test/org/neuclear/asset/controllers/currency

Modified Files:
	CurrencyTests.java 
Added Files:
	IssuanceTests.java 
Log Message:
Added two new Data Objects IssuerOrder and IssueReceipt for managing the issuance process.
Added Issuance support to the Asset and Audit Controllers.
Implemented access control for complete and cancel exchange orders.

Index: CurrencyTests.java
===================================================================
RCS file: /cvsroot/neuclear/neuclear-pay/src/test/org/neuclear/asset/controllers/currency/CurrencyTests.java,v
retrieving revision 1.8
retrieving revision 1.9
diff -C2 -d -r1.8 -r1.9
*** CurrencyTests.java	5 Apr 2004 22:08:24 -0000	1.8
--- CurrencyTests.java	6 Apr 2004 16:24:35 -0000	1.9
***************
*** 18,21 ****
--- 18,22 ----
  import org.neuclear.exchange.orders.builders.ExchangeCompletionOrderBuilder;
  import org.neuclear.exchange.orders.builders.ExchangeOrderBuilder;
+ import org.neuclear.id.InvalidNamedObjectException;
  import org.neuclear.id.SignedNamedObject;
  import org.neuclear.id.builders.Builder;
***************
*** 94,98 ****
      }
  
!     public void testExchangeOrderAndCancel() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
          fundAccount();
          double alicebalance = ledger.getBalance(getAlice().getName());
--- 95,99 ----
      }
  
!     public void testExchangeOrderAndCancelByOwner() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
          fundAccount();
          double alicebalance = ledger.getBalance(getAlice().getName());
***************
*** 115,118 ****
--- 116,164 ----
      }
  
+     public void testExchangeOrderAndCancelByAgent() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
+         fundAccount();
+         double alicebalance = ledger.getBalance(getAlice().getName());
+         assertEquals(alicebalance, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+ 
+         Builder builder = new ExchangeOrderBuilder(asset, agent, new Amount(20), new Date(System.currentTimeMillis() + 5000), new BidItem[]{new BidItem(shoes, new Amount(10))}, "give me shoes");
+         SignedNamedObject receipt = process(builder);
+         assertNotNull(receipt);
+         assertTrue(receipt instanceof ExchangeOrderReceipt);
+         assertEquals(alicebalance, ledger.getBalance(getAlice().getName()), 0);
+         assertEquals(alicebalance - 20, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+         SignedNamedObject cr = processAgent(new CancelExchangeOrderBuilder((ExchangeOrderReceipt) receipt));
+         assertNotNull(cr);
+         assertTrue(cr instanceof CancelExchangeReceipt);
+         assertEquals(alicebalance, ledger.getBalance(getAlice().getName()), 0);
+         assertEquals(alicebalance, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+     }
+ 
+     public void testFailOnExchangeOrderAndCancelByBaddie() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
+         fundAccount();
+         double alicebalance = ledger.getBalance(getAlice().getName());
+         assertEquals(alicebalance, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+ 
+         Builder builder = new ExchangeOrderBuilder(asset, agent, new Amount(20), new Date(System.currentTimeMillis() + 8000), new BidItem[]{new BidItem(shoes, new Amount(10))}, "give me shoes");
+         SignedNamedObject receipt = process(builder);
+         assertNotNull(receipt);
+         assertTrue(receipt instanceof ExchangeOrderReceipt);
+         assertEquals(alicebalance, ledger.getBalance(getAlice().getName()), 0);
+         assertEquals(alicebalance - 20, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+         try {
+             SignedNamedObject cr = processHacker(new CancelExchangeOrderBuilder((ExchangeOrderReceipt) receipt));
+             assertTrue(false);
+         } catch (InvalidNamedObjectException e) {
+             assertTrue(true);
+         }
+         assertEquals(alicebalance, ledger.getBalance(getAlice().getName()), 0);
+         assertEquals(alicebalance - 20, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+     }
+ 
      public void testExchangeOrderAndComplete() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
          fundAccount();
***************
*** 129,133 ****
          assertAudit(getAlice().getName());
  
!         SignedNamedObject cr = process(new ExchangeCompletionOrderBuilder((ExchangeOrderReceipt) receipt, new Date(), getBob().getName(), new Amount(18), "done"));
          assertNotNull(cr);
          assertTrue(cr instanceof ExchangeCompletedReceipt);
--- 175,179 ----
          assertAudit(getAlice().getName());
  
!         SignedNamedObject cr = processAgent(new ExchangeCompletionOrderBuilder((ExchangeOrderReceipt) receipt, new Date(), getBob().getName(), new Amount(18), "done"));
          assertNotNull(cr);
          assertTrue(cr instanceof ExchangeCompletedReceipt);
***************
*** 137,140 ****
--- 183,242 ----
      }
  
+     public void testFailOnExchangeOrderAndCompleteByOwner() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
+         fundAccount();
+         double alicebalance = ledger.getBalance(getAlice().getName());
+         assertEquals(alicebalance, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+ 
+         Builder builder = new ExchangeOrderBuilder(asset, agent, new Amount(20), new Date(System.currentTimeMillis() + 20000), new BidItem[]{new BidItem(shoes, new Amount(10))}, "give me shoes");
+         SignedNamedObject receipt = process(builder);
+         assertNotNull(receipt);
+         assertTrue(receipt instanceof ExchangeOrderReceipt);
+         assertEquals(alicebalance, ledger.getBalance(getAlice().getName()), 0);
+         assertEquals(alicebalance - 20, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+ 
+         try {
+             SignedNamedObject cr = process(new ExchangeCompletionOrderBuilder((ExchangeOrderReceipt) receipt, new Date(), getBob().getName(), new Amount(18), "done"));
+             assertTrue(false);
+         } catch (InvalidNamedObjectException e) {
+             assertTrue(true);
+         } catch (InvalidTransferException e) {
+             assertTrue(true);
+         }
+ 
+         assertEquals(alicebalance, ledger.getBalance(getAlice().getName()), 0);
+         assertEquals(alicebalance - 20, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+     }
+ 
+     public void testFailOnExchangeOrderAndCompleteByBaddie() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
+         fundAccount();
+         double alicebalance = ledger.getBalance(getAlice().getName());
+         assertEquals(alicebalance, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+ 
+         Builder builder = new ExchangeOrderBuilder(asset, agent, new Amount(20), new Date(System.currentTimeMillis() + 20000), new BidItem[]{new BidItem(shoes, new Amount(10))}, "give me shoes");
+         SignedNamedObject receipt = process(builder);
+         assertNotNull(receipt);
+         assertTrue(receipt instanceof ExchangeOrderReceipt);
+         assertEquals(alicebalance, ledger.getBalance(getAlice().getName()), 0);
+         assertEquals(alicebalance - 20, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+ 
+         try {
+             SignedNamedObject cr = processHacker(new ExchangeCompletionOrderBuilder((ExchangeOrderReceipt) receipt, new Date(), getBob().getName(), new Amount(18), "done"));
+             assertTrue(false);
+         } catch (InvalidNamedObjectException e) {
+             assertTrue(true);
+         } catch (InvalidTransferException e) {
+             assertTrue(true);
+         }
+ 
+         assertEquals(alicebalance, ledger.getBalance(getAlice().getName()), 0);
+         assertEquals(alicebalance - 20, ledger.getAvailableBalance(getAlice().getName()), 0);
+         assertAudit(getAlice().getName());
+     }
+ 
      private SignedNamedObject process(Builder builder) throws NeuClearException {
          final SignedNamedObject obj = builder.convert("neu://alice@test", getSigner());
***************
*** 143,146 ****
--- 245,261 ----
      }
  
+     private SignedNamedObject processAgent(Builder builder) throws NeuClearException {
+         final SignedNamedObject obj = builder.convert("neu://bob@test", getSigner());
+ 
+         return auditor.receive(proc.receive(obj));
+     }
+ 
+     private SignedNamedObject processHacker(Builder builder) throws NeuClearException {
+         final SignedNamedObject obj = builder.convert("neu://test", getSigner());
+ 
+         return auditor.receive(proc.receive(obj));
+     }
+ 
+ 
      public Asset createTestAsset() throws NeuClearException {
          AssetBuilder builder = new AssetBuilder("http://bux.neuclear.org",

--- NEW FILE: IssuanceTests.java ---
package org.neuclear.asset.controllers.currency;

import org.neuclear.asset.Auditor;
import org.neuclear.asset.InvalidTransferException;
import org.neuclear.asset.contracts.Asset;
import org.neuclear.asset.contracts.builders.AssetBuilder;
import org.neuclear.asset.orders.Amount;
import org.neuclear.asset.orders.IssueReceipt;
import org.neuclear.asset.orders.builders.IssueOrderBuilder;
import org.neuclear.commons.NeuClearException;
import org.neuclear.id.InvalidNamedObjectException;
import org.neuclear.id.SignedNamedObject;
import org.neuclear.id.builders.Builder;
import org.neuclear.id.receiver.Receiver;
import org.neuclear.ledger.InvalidTransactionException;
import org.neuclear.ledger.Ledger;
import org.neuclear.ledger.LowlevelLedgerException;
import org.neuclear.ledger.simple.SimpleLedger;
import org.neuclear.tests.AbstractSigningTest;

import java.security.GeneralSecurityException;

/**
 * In this unit test Alice is the Issuer.
 */
public final class IssuanceTests extends AbstractSigningTest {
    public IssuanceTests(final String s) throws LowlevelLedgerException, GeneralSecurityException, NeuClearException {
        super(s);
        asset = createTestAsset();
        ledger = new SimpleLedger("test");
        proc = new CurrencyController(ledger, asset, getSigner(), "neu://test/bux");
        auditLedger = new SimpleLedger("auditor");
        auditor = new Auditor(asset, auditLedger);
    }

    public void testSimpleIssuance() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
        // Sanity Check

        assertAudit(getBob().getName());
        assertAudit(getAlice().getName());

        double issuerBalance = ledger.getBalance(getAlice().getName());
        double bobBalance = ledger.getBalance(getBob().getName());

        assertEquals(bobBalance, ledger.getAvailableBalance(getBob().getName()), 0);

        final int amount = 1000;

        Builder builder = new IssueOrderBuilder(asset, getBob(), new Amount(amount), "fund");
        SignedNamedObject receipt = process(builder);
        assertNotNull(receipt);
        assertTrue(receipt instanceof IssueReceipt);
        assertEquals(issuerBalance - amount, ledger.getAvailableBalance(getAlice().getName()), 0);
        assertEquals(issuerBalance - amount, ledger.getBalance(getAlice().getName()), 0);
        assertEquals(bobBalance + amount, ledger.getAvailableBalance(getBob().getName()), 0);
        assertEquals(bobBalance + amount, ledger.getBalance(getBob().getName()), 0);
        assertAudit(getBob().getName());
        assertAudit(getAlice().getName());
        assertTrue(ledger.isBalanced());
        assertTrue(auditLedger.isBalanced());
    }

/*
    public void testNegativeIssuance() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
        // Sanity Check

        assertAudit(getBob().getName());
        assertAudit(getAlice().getName());

        double issuerBalance = ledger.getBalance(getAlice().getName());
        double bobBalance = ledger.getBalance(getBob().getName());

        assertEquals(bobBalance, ledger.getAvailableBalance(getBob().getName()), 0);

        final int amount = -1000;

        Builder builder = new IssueOrderBuilder(asset, getBob(), new Amount(amount), "fund");
        SignedNamedObject receipt = process(builder);
        assertNotNull(receipt);
        assertTrue(receipt instanceof IssueReceipt);
        assertEquals(issuerBalance - amount, ledger.getAvailableBalance(getAlice().getName()), 0);
        assertEquals(issuerBalance - amount, ledger.getBalance(getAlice().getName()), 0);
        assertEquals(bobBalance + amount, ledger.getAvailableBalance(getBob().getName()), 0);
        assertEquals(bobBalance + amount, ledger.getBalance(getBob().getName()), 0);
        assertAudit(getBob().getName());
        assertAudit(getAlice().getName());
        assertTrue(ledger.isBalanced());
        assertTrue(auditLedger.isBalanced());
    }
*/

    public void testFailOnIllegalIssuance() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
        // Sanity Check

        assertAudit(getBob().getName());
        assertAudit(getAlice().getName());

        double issuerBalance = ledger.getBalance(getAlice().getName());
        double bobBalance = ledger.getBalance(getBob().getName());

        assertEquals(bobBalance, ledger.getAvailableBalance(getBob().getName()), 0);

        final int amount = 1000;

        try {
            Builder builder = new IssueOrderBuilder(asset, getAlice(), new Amount(amount), "fund");
            SignedNamedObject receipt = processIlegal(builder);
            assertNull(receipt);
            assertFalse(receipt instanceof IssueReceipt);
            assertTrue(false);
        } catch (InvalidNamedObjectException e) {
            assertTrue(true);
        } catch (InvalidTransferException e) {
            assertTrue(true);
        }
        assertEquals(issuerBalance, ledger.getAvailableBalance(getAlice().getName()), 0);
        assertEquals(issuerBalance, ledger.getBalance(getAlice().getName()), 0);
        assertEquals(bobBalance, ledger.getAvailableBalance(getBob().getName()), 0);
        assertEquals(bobBalance, ledger.getBalance(getBob().getName()), 0);
        assertAudit(getBob().getName());
        assertAudit(getAlice().getName());
        assertTrue(ledger.isBalanced());
        assertTrue(auditLedger.isBalanced());
    }

    public void testFailOnIllegalNegativeIssuance() throws InvalidTransferException, NeuClearException, InvalidTransactionException, LowlevelLedgerException {
        // Sanity Check

        assertAudit(getBob().getName());
        assertAudit(getAlice().getName());

        double issuerBalance = ledger.getBalance(getAlice().getName());
        double bobBalance = ledger.getBalance(getBob().getName());

        assertEquals(bobBalance, ledger.getAvailableBalance(getBob().getName()), 0);

        final int amount = -1000;

        try {
            Builder builder = new IssueOrderBuilder(asset, getAlice(), new Amount(amount), "fund");
            SignedNamedObject receipt = processIlegal(builder);
            assertNull(receipt);
            assertFalse(receipt instanceof IssueReceipt);
            assertTrue(false);
        } catch (InvalidNamedObjectException e) {
            assertTrue(true);
        } catch (InvalidTransferException e) {
            assertTrue(true);
        }
        assertEquals(issuerBalance, ledger.getAvailableBalance(getAlice().getName()), 0);
        assertEquals(issuerBalance, ledger.getBalance(getAlice().getName()), 0);
        assertEquals(bobBalance, ledger.getAvailableBalance(getBob().getName()), 0);
        assertEquals(bobBalance, ledger.getBalance(getBob().getName()), 0);
        assertAudit(getBob().getName());
        assertAudit(getAlice().getName());
        assertTrue(ledger.isBalanced());
        assertTrue(auditLedger.isBalanced());
    }

    public void assertAudit(String name) throws LowlevelLedgerException {
        assertEquals(auditLedger.getBalance(name), ledger.getBalance(name), 0);
        assertEquals(auditLedger.getAvailableBalance(name), ledger.getAvailableBalance(name), 0);
    }

    private SignedNamedObject process(Builder builder) throws NeuClearException {
        final SignedNamedObject obj = builder.convert("neu://alice@test", getSigner());

        return auditor.receive(proc.receive(obj));
    }

    private SignedNamedObject processIlegal(Builder builder) throws NeuClearException {
        final SignedNamedObject obj = builder.convert("neu://bob@test", getSigner());

        return auditor.receive(proc.receive(obj));
    }

    public Asset createTestAsset() throws NeuClearException {
        AssetBuilder builder = new AssetBuilder("http://bux.neuclear.org",
                getSigner().getPublicKey("neu://test/bux"),
                getAlice().getPublicKey(),
                2, 0);
        return (Asset) builder.convert("neu://test/bux", getSigner());

    }

    private Receiver proc;
    private Ledger ledger;
    private Ledger auditLedger;
    private Auditor auditor;
    private Asset asset;


}