add tests for creating, adding to, and drawing from raffles (#4)

* add tests for creating, adding to, and drawin from raffles

* move to generic raffle source

contracts/RaffleSources.cdc

@@ -0,0 +1,49 @@
+import "Raffles"
+
+pub contract RaffleSources {
+    pub resource GenericRaffleSource: Raffles.RaffleSource {
+        pub let entries: [AnyStruct]
+        pub let entryType: Type
+
+        pub fun getEntryType(): Type {
+            return self.entryType
+        }
+
+        pub fun getEntryAt(index: Int): AnyStruct {
+            return self.entries[index]
+        }
+
+        pub fun addEntry(_ v: AnyStruct) {
+            pre {
+                v.getType() == self.entryType: "incorrect entry type"
+            }
+
+            self.entries.append(v)
+        }
+
+        pub fun addEntries(_ v: [AnyStruct]) {
+            pre { 
+                VariableSizedArrayType(self.entryType) == v.getType(): "incorrect array type"
+            }
+
+            self.entries.appendAll(v)
+        }
+
+        pub fun getNumEntries(): Int {
+            return self.entries.length
+        }
+
+        pub fun getEntries(): [AnyStruct] {
+            return self.entries
+        }
+
+        init(_ entryType: Type) {
+            self.entries = []
+            self.entryType = entryType
+        }
+    }
+
+    pub fun createRaffleSource(_ type: Type): @GenericRaffleSource {
+        return <- create GenericRaffleSource(type)
+    }
+}

contracts/Raffles.cdc

@@ -4,8 +4,8 @@ pub contract Raffles {
     pub let ManagerStoragePath: StoragePath
     pub let ManagerPublicPath: PublicPath
 
-    pub event RaffleCreated(address: Address, raffleID: UInt64, sourceType: Type)
-    pub event RaffleDrawn(address: Address, raffleID: UInt64, sourceType: Type, index: Int, value: String)
+    pub event RaffleCreated(address: Address?, raffleID: UInt64, sourceType: Type)
+    pub event RaffleDrawn(address: Address?, raffleID: UInt64, sourceType: Type, index: Int, value: String, valueType: Type)
 
     pub struct Details {
         pub let start: UInt64?
@@ -14,7 +14,7 @@ pub contract Raffles {
 
         init(
             _ start: UInt64?,
-            _ end: UInt64,
+            _ end: UInt64?,
             _ display: MetadataViews.Display
 
         ) {
@@ -24,22 +24,70 @@ pub contract Raffles {
         }
     }
 
+    pub struct DrawingSelection {
+        pub let index: Int
+        pub let value: AnyStruct
+
+        init(_ index: Int, _ value: AnyStruct) {
+            self.index = index
+            self.value = value
+        }
+    }
+
     pub resource interface RafflePublic {
         pub fun getEntryAt(index: Int): AnyStruct
+        pub fun getDetails(): Details
+        pub fun getNumEntries(): Int
+        pub fun getEntries(): [AnyStruct]
+        pub fun draw(): DrawingSelection
+    }
+
+    pub resource interface RaffleSource {
+        pub fun getEntryAt(index: Int): AnyStruct
+        pub fun addEntry(_ v: AnyStruct)
+        pub fun addEntries(_ v: [AnyStruct])
+        pub fun getNumEntries(): Int
+        pub fun getEntries(): [AnyStruct]
     }
 
     pub resource Raffle: RafflePublic, MetadataViews.Resolver {
         pub let source: @{RaffleSource}
         pub let details: Details
 
-        pub fun draw(): Int {
-            return self.source.draw()
+        pub fun getDetails(): Details {
+            return self.details
+        }
+
+        pub fun getNumEntries(): Int {
+            return self.source.getNumEntries()
+        }
+
+        pub fun getEntries(): [AnyStruct] {
+            return self.source.getEntries()
+        }
+
+        pub fun draw(): DrawingSelection {
+            let numEntries = self.source.getNumEntries()
+            let r = revertibleRandom()
+            let index = Int(r % UInt64(numEntries))
+            let value = self.source.getEntryAt(index: index)
+
+            Raffles.emitDrawing(self.owner?.address, self.uuid, self.source.getType(), index, value)
+            return DrawingSelection(index, value)
         }
 
         pub fun getEntryAt(index: Int): AnyStruct {
             return self.source.getEntryAt(index: index)
         }
 
+        pub fun addEntry(_ v: AnyStruct) {
+            self.source.addEntry(v)
+        }
+
+        pub fun addEntries(_ v: [AnyStruct]) {
+            self.source.addEntries(v)
+        }
+
         pub fun getViews(): [Type] {
             return [
                 Type<MetadataViews.Display>()
@@ -68,36 +116,30 @@ pub contract Raffles {
         }
     }
 
-    pub resource interface RaffleSource {
-        pub fun draw(): Int
-        pub fun getEntryAt(index: Int): AnyStruct
-    }
-
-    pub resource AddressRaffleSource: RaffleSource {
-        pub let addresses: [Address]
-
-        pub fun draw(): Int {
-            let r = revertibleRandom()
-            return Int(r % UInt64(self.addresses.length))
-        }
-
-        pub fun getEntryAt(index: Int): AnyStruct {
-            return self.addresses[index]
-        }
-
-        init() {
-            self.addresses = []
-        }
-    }
-
     pub resource interface ManagerPublic {
         pub fun borrowRafflePublic(id: UInt64): &{RafflePublic}?
     }
 
     pub resource Manager: ManagerPublic {
         access(self) let raffles: @{UInt64: Raffle}
 
+        pub fun createRaffle(source: @{RaffleSource}, details: Details): UInt64 {
+            let sourceType = source.getType()
+
+            let raffle <- create Raffle(source: <- source, details: details)
+            emit RaffleCreated(address: self.owner!.address, raffleID: raffle.uuid, sourceType: sourceType)
+
+            let id = raffle.uuid
+            destroy self.raffles.insert(key: id, <-raffle)
+
+            return id
+        }
+
         pub fun borrowRafflePublic(id: UInt64): &{RafflePublic}? {
+            return self.borrowRaffle(id: id)
+        }
+
+        pub fun borrowRaffle(id: UInt64): &Raffle? {
             if self.raffles[id] == nil {
                 return nil
             }
@@ -114,7 +156,7 @@ pub contract Raffles {
         }
     }
 
-    access(contract) fun emitDrawing(address: Address, raffleID: UInt64, sourceType: Type, index: Int, value: AnyStruct) {
+    access(contract) fun emitDrawing(_ address: Address?, _ raffleID: UInt64, _ sourceType: Type, _ index: Int, _ value: AnyStruct) {
         var v = "UNKNOWN"
         switch value.getType() {
             case Type<Address>():
@@ -125,26 +167,13 @@ pub contract Raffles {
                 break
         }
 
-        emit RaffleDrawn(address: address, raffleID: raffleID, sourceType: sourceType, index: index, value: v)
+        emit RaffleDrawn(address: address, raffleID: raffleID, sourceType: sourceType, index: index, value: v, valueType: value.getType())
     }
 
     pub fun createManager(): @Manager {
         return <- create Manager()
     }
 
-    pub fun createRaffle(source: @{RaffleSource}, details: Details): @Raffle {
-        return <- create Raffle(source: <- source, details: details)        
-    }
-
-    pub fun createRaffleSource(_ type: Type): @{RaffleSource} {
-        switch type {
-            case Type<@AddressRaffleSource>():
-                return <- create AddressRaffleSource()
-        }
-
-        panic("raffle source type ".concat(type.identifier).concat(" is not valid"))
-    }
-
     init() {
         let identifier = "Raffle_".concat(self.account.address.toString())
         self.ManagerStoragePath = StoragePath(identifier: identifier)!

flow.json

@@ -26,6 +26,12 @@
         "testing": "0x0000000000000007"
       }
     },
+    "RaffleSources": {
+      "source": "./contracts/RaffleSources.cdc",
+      "aliases": {
+        "testing": "0x0000000000000008"
+      }
+    },
     "FungibleToken": {
       "source": "./node_modules/@flowtyio/flow-contracts/contracts/FungibleToken.cdc",
       "aliases": {

scripts/get_num_raffle_entries.cdc

@@ -0,0 +1,11 @@
+import "Raffles"
+
+pub fun main(addr: Address, id: UInt64): Int {
+    let acct = getAuthAccount(addr)
+    let manager = acct.borrow<&Raffles.Manager{Raffles.ManagerPublic}>(from: Raffles.ManagerStoragePath)
+        ?? panic("raffles manager not found")
+    let raffle = manager.borrowRafflePublic(id: id)
+        ?? panic("raffle not found")
+
+    return raffle.getNumEntries()
+}

scripts/get_raffle_details.cdc

@@ -0,0 +1,13 @@
+import "Raffles"
+
+pub fun main(addr: Address, id: UInt64): Raffles.Details? {
+    let acct = getAuthAccount(addr)
+    let manager = acct.borrow<&Raffles.Manager>(from: Raffles.ManagerStoragePath)
+        ?? panic("raffles manager not found")
+
+    if let raffle = manager.borrowRafflePublic(id: id) {
+        return raffle.getDetails()
+    }
+
+    return nil
+}

scripts/get_raffle_entries.cdc

@@ -0,0 +1,11 @@
+import "Raffles"
+
+pub fun main(addr: Address, id: UInt64): [AnyStruct] {
+    let acct = getAuthAccount(addr)
+    let manager = acct.borrow<&Raffles.Manager{Raffles.ManagerPublic}>(from: Raffles.ManagerStoragePath)
+        ?? panic("raffles manager not found")
+    let raffle = manager.borrowRafflePublic(id: id)
+        ?? panic("raffle not found")
+
+    return raffle.getEntries()
+}

scripts/get_raffle_source_identifier.cdc

@@ -0,0 +1,7 @@
+import "Raffles"
+
+pub fun main(addr: Address, path: StoragePath): String {
+    let acct = getAuthAccount(addr)
+    let source = acct.borrow<&{Raffles.RaffleSource}>(from: path)
+    return source!.getType().identifier
+}