test.da

import sys, time
from master import Master
from client import GFSClient
from ProcessMonitor import ProcessMonitor
config(channel is fifo, clock is lamport)

def main():
    processMon = new(ProcessMonitor)
    setup(processMon, ())
    start(processMon)
    output('PMON started')
    master1 = new(Master)
    setup(master1, ())
    start(master1)
    client1 = new(GFSClient)
    setup(client1, (master1,processMon))
    start(client1)
    client2 = new(GFSClient)
    setup(client2, (master1,processMon))
    start(client2)
    client3 = new(GFSClient)
    setup(client3, (master1,processMon))
    start(client3)
    client4 = new(GFSClient)
    setup(client4, (master1,processMon))
    start(client4)
    client5 = new(GFSClient)
    setup(client5, (master1,processMon))
    start(client5)
    s1 = 'Hi testing 12'
    s2 = 'Hi testing 456'
    fileNameOne = 'file1.txt'
    fileNameTwo = 'file2.txt'
    fileNameThree = 'file3.txt'
    fileNameFour = 'file4.txt'
    fileNameFive = 'file5.txt'
    testCase = int(sys.argv[1]) if len(sys.argv) > 1 else 0

    if(testCase == 0):
        #Testing Create (Negative Test Case)
        output("************Testing Create Function**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('ERROR_CREATE', message))))
        assert(message == 'File error, file exists already')
        output("************End of Test Case*********************")

    if(testCase == 1):
        #Testing Write (Negative Test Case)
        output("************Testing Write Function**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('WRITE_MSG',fileNameOne, s1), to=client3)
        await(some(received(('WRITTEN', fileName2)),has=fileNameOne == fileName2))
        send(('WRITE_MSG',fileNameTwo, s1), to=client2)
        await(some(received(('ERROR_WRITE', message))))
        assert(message == 'File error, file doesnt exists')
        output("************End of Test Case*********************")

    if(testCase == 2):
        #Testing Delete (Negative Test Case)
        output("************Testing Delete Function**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('DELETE',fileNameTwo), to = client1)
        await(some(received(('ERROR_DELETE', message))))
        assert(message == 'File Doesnt Exist to Delete')
        output("************End of Test Case*********************")

    if(testCase == 3):
        #Testing READ (Negative Test Case)
        output("************Testing Read Function**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        c = logical_clock()
        send(('READ_MSG',c,fileNameTwo), to=client4) 
        await(some(received(('ERROR_READ', message))))
        assert(message == 'File Doesnt Exist to read')
        output("************End of Test Case*********************")
    
    if(testCase == 4):
        #Testing Record Append (Negative Test Case)
        output("************Testing Record Append Function**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('RECORD_APPEND_MSG',fileNameTwo, s2), to=client3)
        await(some(received(('ERROR_APPEND', message))))
        assert(message == 'File Doesnt Exist to do record append')
        output("************End of Test Case*********************")
         
    if(testCase == 5):
        #Testing Snapshot (Negative Test Case)
        output("************Testing Snapshot Function**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('CREATE_SNAPSHOT',fileNameTwo), to = client1)
        await(some(received(('ERROR_SNAPSHOT', message))))
        assert(message == 'File Doesnt Exist to create Snapshot')
        output("************End of Test Case*********************")

    if(testCase == 6):
        #Testing Create (Positive Test Case)
        output("************Testing Create Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        await(some(received(('CREATE_SUCCESS', message))))
        assert(message == 'File Create Success')
        output('**********File created successfully********',fileNameOne)
        output("************End of Test Case*********************")


    if(testCase == 7):
        #Testing Write (Positive Test Case)
        output("************Testing Write Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('WRITE_MSG',fileNameOne, s1), to=client3)
        await(some(received(('WRITTEN', fileName2)),has=fileNameOne == fileName2))
        await(some(received(('WRITE_SUCCESS', message))))
        assert(message == 'File Write Success')   
        output('**********File written successfully********',fileNameOne)
        output("************End of Test Case*********************")

    if(testCase == 8):
        #Testing Delete (Positive Test Case)
        output("************Testing Delete Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('DELETE',fileNameOne), to = client1)
        await(some(received(('DELETE_DONE', fileName2,message)),has=fileNameOne == fileName2))
        assert(message == 'File Delete Success')       
        output('**********File deleted successfully********',fileNameOne)
        output("************End of Test Case*********************")
 
    if(testCase == 9):
        #Testing READ (Positive Test Case)
        output("************Testing Read Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('WRITE_MSG',fileNameOne, s1), to=client3)
        await(some(received(('WRITTEN', fileName2)),has=fileNameOne == fileName2))
        c = logical_clock()
        send(('READ_MSG',c,fileNameOne), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameOne == fileName2 and c2 > c))

        assert(dataRead == s1)
        output('**********File read successfully********',fileNameOne)
        output('*************Data Read is ***********',dataRead)
        output("************End of Test Case*********************") 

    if(testCase == 10):
        #Testing Record Append (Positive Test Case)
        output("************Testing Record Append Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client1)
        await(some(received(('RECORD_APPEND_DONE',))))
        output('**********Record appended successfully********',fileNameOne)
        c = logical_clock()
        send(('READ_MSG',c,fileNameOne), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameOne == fileName2))
        assert(dataRead == s2)
        output('*************Data written to File is***********',dataRead)
        output("************End of Test Case*********************")


    if(testCase == 11):
        #Testing Snapshot (Positive Test Case)
        output("************Testing Snapshot Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client4)
        time.sleep(2)
        send(('CREATE_SNAPSHOT',fileNameOne), to = client1)
        time.sleep(2)
        await(some(received(('SNAPSHOT_SUCCESS', message))))
        assert(message == 'Snapshot Create Success') 
        output('**************Snapshot Created successfully*******************')
        c = logical_clock()
        send(('READ_MSG',c,fileNameOne), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameOne == fileName2 and c2>c))
        assert(s2 == dataRead)
        output('**************Data Read From Snapshot is *******************',dataRead)
        output("************End of Test Case*********************")  
        
    if(testCase == 12): 
        #End-To-End Testing
        output("************Testing End-to-End Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('CREATE_MSG',fileNameTwo), to=client2)
        await(some(received(('CREATED', fileName2)), has=fileNameTwo == fileName2))
        send(('WRITE_MSG',fileNameOne, s1), to=client3)
        await(some(received(('WRITTEN', fileName2)),has=fileNameOne == fileName2))
        s2 = 'Append1232'
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client1)
        time.sleep(1)
        s2 = 'Append4'
        send(('RECORD_APPEND_MSG',fileNameTwo, s2), to=client2) 
        time.sleep(1)
        s2 = 'Append5'
        send(('DELETE',fileNameOne), to = client1)
        await(some(received(('DELETE_DONE', fileName2,message)),has=fileNameOne == fileName2))
        assert(message == 'File Delete Success')       
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client3)
        await(some(received(('ERROR_APPEND', message))))
        assert(message == 'File Doesnt Exist to do record append')
        time.sleep(1)
        s2 = 'Appending 6666'
        send(('RECORD_APPEND_MSG',fileNameTwo, s2), to=client4)
        time.sleep(2)
        send(('CREATE_SNAPSHOT',fileNameTwo), to = client1)
        time.sleep(15)
        send(('CREATE_SNAPSHOT',fileNameTwo), to = client2)
        time.sleep(15)
        appended = 'Append4Appending 6666'
        c = logical_clock()
        send(('READ_MSG',c,fileNameTwo), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameTwo == fileName2 and c2>c))
        assert(appended == dataRead)
        output('*************Data Read from File is***********',dataRead)
        send(('DELETE',fileNameOne), to = client1)
        await(received(('DONE',)))

    elif(testCase == 13): 
        #End-To-End Testing
        output("************Testing End-to-End Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('CREATE_MSG',fileNameTwo), to=client2)
        await(some(received(('CREATED', fileName2)), has=fileNameTwo == fileName2))
        send(('WRITE_MSG',fileNameTwo, s1), to=client3)
        await(some(received(('WRITTEN', fileName2)),has=fileNameTwo == fileName2))
        s2 = 'Append1232'
        send(('CREATE_SNAPSHOT',fileNameTwo), to = client3)
        time.sleep(2)
        appended = s1
        c = logical_clock()
        send(('READ_MSG',c,fileNameTwo), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameTwo == fileName2 and c2>c))
        assert(appended == dataRead)
        output('*******************THIS IS THE DATA READ from file**********************',dataRead)
        c = logical_clock()
        send(('READ_MSG',c,fileNameTwo), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameTwo == fileName2))
        assert(appended == dataRead)
        output('*******************THIS IS THE DATA READ from file**********************',dataRead)
        c = logical_clock()
        send(('READ_MSG',c,fileNameTwo), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameTwo == fileName2))
        assert(appended == dataRead)
        output('*******************THIS IS THE DATA READ from file**********************',dataRead)
        c = logical_clock()
        send(('READ_MSG',c,fileNameThree), to=client4) 
        await(some(received(('ERROR_READ', message))))
        assert(message == 'File Doesnt Exist to read')
        await(received(('DONE',)))

    elif(testCase == 14):
        #End-To-End Testing
        output("************Testing End-to-End Functionality**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('CREATE_MSG',fileNameTwo), to=client2)
        await(some(received(('CREATED', fileName2)), has=fileNameTwo == fileName2))
        send(('WRITE_MSG',fileNameThree, s1), to=client3)
        await(some(received(('ERROR_WRITE', message))))
        assert(message == 'File error, file doesnt exists')
        s2 = 'Append1232'
        send(('RECORD_APPEND_MSG',fileNameTwo, s2), to=client1)
        time.sleep(1)
        send(('CREATE_SNAPSHOT',fileNameTwo), to = client3)
        time.sleep(2)
        c = logical_clock()
        send(('READ_MSG',c,fileNameOne), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameOne == fileName2 and c2>c))
        output('****************************THIS IS THE DATA READ from file*******************',dataRead)
        assert(dataRead == '')
        c = logical_clock()
        send(('READ_MSG',c,fileNameThree), to=client4) 
        send(('DELETE',fileNameOne), to = client1)
        await(received(('DONE',)))

    elif(testCase == 15):
        #End-To-End Consistency Testing
        output("************Testing Consistency**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        s2 = 'Append1232'
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client1)
        time.sleep(1)
        s2 = 'Append4'
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client2) 
        time.sleep(1)
        s2 = 'Append5'
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client3)
        time.sleep(1)
        appended = 'Append1232Append4Append5'
        c=logical_clock()
        send(('READ_MSG',c,fileNameOne), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameOne == fileName2 and c2>c))
        assert(dataRead == appended)
        output('***************Data Appended in Order ***************',appended)
        output('***************Data Read from file is ***************',dataRead)
        s2 = 'Append6'
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client3)
        time.sleep(1)
        send(('CREATE_SNAPSHOT',fileNameOne), to = client1)
        time.sleep(1)
        send(('CREATE_SNAPSHOT',fileNameOne), to = client2)
        time.sleep(1)
        c=logical_clock()
        send(('READ_MSG',c,fileNameOne), to=client4) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                        has=fileNameOne == fileName2 and c2>c))
        output('***************Data Read from file is ***************',dataRead)
        send(('DELETE',fileNameOne), to = client1)
        await(received(('DONE',)))

    elif(testCase == 16):
        #End-To-End Availability Testing
        output("************Testing Availability**************")
        send(('CREATE_MSG',fileNameOne), to=client1)
        await(some(received(('CREATED', fileName2)), has=fileNameOne == fileName2))
        send(('WRITE_MSG',fileNameOne, s1), to=client1)
        await(some(received(('WRITTEN', fileName2)),has=fileNameOne == fileName2))
        s2 = 'Append1232'
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client1)
        s2 = 'Append2'
        send(('RECORD_APPEND_MSG',fileNameOne, s2), to=client2)
        send(('CREATE_SNAPSHOT',fileNameOne), to = client3)
        time.sleep(2)
        c=logical_clock()
        send(('READ_MSG',c,fileNameOne), to=client1) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                    has=fileNameOne == fileName2 and c2>c))
        beforeKill = dataRead
        output('****************Data Read before killing chunk server ***********',dataRead)
        output('************Killing Chunk Server***********************')
        c=logical_clock()
        send(('KILL_CHUNKSERVER',c), to=client2)
        await(some(received(('KILL',chunkServer,c2)), 
                                    has=c2>c))
        output(chunkServer)
        send(('DONE',), to =chunkServer)
        time.sleep(3)
        c= logical_clock()
        send(('READ_MSG',c,fileNameOne), to=client1) 
        await(some(received(('READ_FILE_DONE',dataRead,fileName2,c2)), 
                                    has=fileNameOne == fileName2 and c2>c))
        afterKill = dataRead
        assert(beforeKill == afterKill)
        output('****************Data Read after killing chunk server ***********',dataRead)
        send(('DELETE',fileNameOne), to = client1)
        await(received(('DONE',)))
        output("************End of Test Case*********************")