# -*-html-*-

pcp   = ../src/pcp1
vault = v1
passwd = xxx

<test check-show-help>
  cmd    = $pcp -h
  expect = /export/
</test>

<test check-if-fail-without-vault>
  prepare = rm -f $vault
  cmd     = $pcp -V $vault -l
  expect  = /doesn't contain any keys so far/
</test>

<test check-generate-secret-key>
  cmd  = $pcp -V $vault -k -x $passwd
  input = <<EOF
Dexter Morgan
dxmorg@florida.cops.gov
  EOF
  expect = /Generated new secret key/	     
</test>


<test check-if-vault-contains-secret>
  cmd = $pcp -V $vault -l
  expect = /Dexter Morgan/
</test>

<test check-secret-key-info>
  cmd = $pcp -V $vault -l | tail -1 | cut -d ' ' -f 1 | xargs $pcp -V $vault -t -i
  expect = /BEGIN PCP SECRET KEY/
</test>

<test check-export-public-key>
  cmd = $pcp -V $vault -l | tail -1 | cut -d ' ' -f 1 | xargs $pcp -V $vault -p -i 
  expect = /BEGIN PCP PUBLIC KEY/
</test>

<test check-export-public-key-tofile>
  cmd = $pcp -V $vault -l | tail -1 | cut -d ' ' -f 1 | xargs $pcp -V $vault -p -O testkey-self -i 
  expect-file = testkey-self
</test>

<test check-export-public-key-filecontent>
  cmd = /usr/bin/true # file is already there
  expect-file-contains = testkey-self Dexter
</test>

<test check-import-public-key>
  cmd = $pcp -V $vault -P -I bart.pub
  expect = /key 0x0E4512BE47CE0215 added/
</test>

<test check-imported-public-key-info>
  cmd = $pcp -V $vault -t -i 0x0E4512BE47CE0215
  expect = /Serial Number: 0xEE894128/
</test>

<test check-if-delete-public-key-works>
  cmd = $pcp -V $vault -r -i 0x0E4512BE47CE0215
  expect = /Public key deleted/
</test>

<test check-if-vault-still-valid>
  cmd = $pcp -V $vault -t
  expect = /Vault version: 00000001/
</test>

<test check-if-deleted-public-key-is-away>
  cmd = $pcp -V $vault -t
  expect = /Public keys: 0/
</test>

#
# encryption tests
idbobby  = 0x68832D215AFB2440
idalicia = 0xE2942C2B6C96F6CC
md5msg   = 66b8c4ca9e5d2a7e3c0559c3cdea3d50
<test check-crypto-alicia-init>
  prepare = echo ${md5msg} > testmessage
  <test check-crypto-alicia-import-secret>
    cmd = $pcp -V va -S -I key-alicia-sec -x a
    expect = /${idalicia}/
  </test>

  <test check-crypto-alicia-import-bobbys-key>
    cmd = $pcp -V va -P -I key-bobby-pub
    expect = /${idbobby}/
  </test>

  <test check-crypto-alicia-encrypt>
    cmd = $pcp -V va -e -i ${idbobby} -I testmessage -O testencrypted -x a
    expect = /for ${idbobby} successfully/
  </test>

  <test check-crypto-alicia-encrypted-file>
    cmd = cat testencrypted
    expect = /END PCP ENCRYPTED FILE/
  </test>
</test>

<test check-crypto-bobby-init>
  <test check-crypto-bobby-import-secret>
    cmd = $pcp -V vb -S -I key-bobby-sec -x b
    expect = /${idbobby}/
  </test>

  <test check-crypto-alicia-import-alicias-key>
    cmd = $pcp -V vb -P -I key-alicia-pub
    expect = /${idalicia}/
  </test>

  <test check-crypto-bobby-decrypt>
    cmd = $pcp -V vb -d -O testdecrypted -I testencrypted -x b
    expect = /from ${idalicia} successfully/
  </test>

  <test check-crypto-alicia-encrypted-file>
    cmd = cat testdecrypted
    expect = /${md5msg}/
  </test>
</test>


#
# negative tests, check for error handling
<test check-if-catch-conflicting-params>
  cmd = $pcp -S -P
  expect = /invalid combination of commandline parameters/
</test>

<test check-infile-error>
  cmd = $pcp -V $vault -I nonexist -P
  expect = /Could not open input file nonexist/
</test>

<test check-import-without-id-error>
  cmd = $pcp -V $vault -r
  expect = /You need to specify a key id/
</test>

<test check-catch-invalid-short-keyid>
  cmd = $pcp -V $vault -r -i 0x1
  expect = /is too short/
</test>

<test check-catch-invalid-long-keyid>
  cmd = $pcp -V $vault -r -i 0x1111111111111111111111111
  expect = /is too long/
</test>

<test check-catch-invalid-long-keyid-without-0x>
  cmd = $pcp -V $vault -r -i 11111111111111111
  expect = /is too long/
</test>

<test check-catch-delete-nonexist>
  cmd = $pcp -V $vault -r -i 0x0101010101010101
  expect = /No key with id 0x010101/
</test>

<test check-if-export-secret-catch-nonexistent-keyid>
  cmd = $pcp -V $vault -s -i 0x0101010101010101
  expect = /Could not find a secret key with id 0x010101/
</test>

<test check-if-export-secret-catch-no-primary>
  prepare = $pcp -V v2 -l # so we've got just an empty vault
  cmd = $pcp -V v2 -s
  expect = /no primary secret key in the vault/
</test>

<test check-if-export-secret-catch-outfile-error>
  cmd =  $pcp -V $vault -l | grep primary |cut -d ' ' -f 1 \
         | xargs $pcp -V $vault -s -O nonexistentdir/keyfile -i
  expect = /Could not create output file nonexistentdir/
</test>


<test check-if-export-public-catch-nonexistent-keyid>
  cmd = $pcp -V $vault -p -i 0x0101010101010101
  expect = /Could not find a public key with id 0x010101/
</test>

<test check-if-export-public-catch-no-primary>
  prepare = $pcp -V v3 -l # so we've got just an empty vault
  cmd = $pcp -V v3 -p
  expect = /no primary secret key in the vault/
</test>

<test check-if-export-public-catch-outfile-error>
  prepare = $pcp -V $vault -P -I bart.pub
  cmd =  $pcp -V $vault -l | grep public | cut -d ' ' -f 1 \
         | tail -1 | xargs $pcp -V $vault -p -O nonexistentdir/keyfile
  expect = /Could not create output file nonexistentdir/
</test>

<test check-if-catch-empty-input>
  prepare = echo -n > testfile-empty
  cmd = $pcp -V $vault -P -I testfile-empty
  expect = /file is empty/
</test>

<test check-if-catch-missing-newlines>
  prepare = jot 5000 | while read ignore; do echo -n X; done > testfile-toolong
  cmd = $pcp -V $vault -P -I testfile-toolong
  expect = /line is too long/
</test>

/*
 * Currently disabled, because ZeroMQ's zmq_z85_decode() doesn't really
 * catch invalid z85, it only checks the input length and not the actual
 * encoding. Re-enable, once that bug is fixed.
<test check-if-catch-invalid-z85>
  prepare = jot 30 | while read ignore; do \
            echo XXXXXXXXXXXXXXXXXX; done > testfile-noz85
  cmd = $pcp -V $vault -P -I testfile-noz85
  expect = /could not decode input/
</test>
*/

<test check-if-catch-nokey-behind-z85>
  prepare = jot 30 | while read ignore; do echo XXXXX; done \
            | $pcp -z > testfile-nokey
  cmd = $pcp -V $vault -P -I testfile-nokey
  expect = /result to a proper sized key/
</test>

<test check-if-sanity-catch-nosecret>
  cmd = $pcp -V $vault -S -I bart.pub
  expect = /result to a proper sized key/
</test>

<test check-if-sanity-catch-keyexists>
  cmd = $pcp -V $vault -P -I bart.pub
  expect = /there already exists a key/
</test>

<test check-if-catch-nokeys>
  prepare = $pcp -V v3 -l
  cmd = $pcp -V v3 -l
  expect = /contain any keys so far/
</test>


<test check-testkey-invalid-id>
  prepare = ./invalidkeys
  cmd = $pcp -V $vault -S -I testkey-invalid-id
  expect /invalid key id/
</test>

<test check-testkey-not-encrypted>
  cmd = $pcp -V $vault -S -I testkey-not-encrypted
  expect = /secret key contained in key seems to be empty/
</test>

<test check-testkey-wrong-serial>
  cmd = $pcp -V $vault -S -I testkey-wrong-serial
  # sometimes the created key is invalid in another way
  expect = /(invalid serial number|could not decode input)/
</test>

<test check-testkey-wrong-type>
  cmd = $pcp -V $vault -S -I testkey-wrong-type
  expect = /key type is not SECRET/
</test>

<test check-testkey-wrong-version>
  cmd = $pcp -V $vault -S -I testkey-wrong-version
  expect = /unknown key version/
</test>



<test check-testpubkey-invalid-id>
  prepare = ./invalidkeys
  cmd = $pcp -V $vault -P -I testpubkey-invalid-id
  expect = /nvalid key id/
</test>

<test check-testpubkey-wrong-serial>
  cmd = $pcp -V $vault -P -I testpubkey-wrong-serial
  expect = /invalid serial number/
</test>

<test check-testpubkey-wrong-type>
  cmd = $pcp -V $vault -P -I testpubkey-wrong-type
  expect = /key type is not PUBLIC/
</test>

<test check-testpubkey-wrong-version>
  cmd = $pcp -V $vault -P -I testpubkey-wrong-version
  expect = /unknown key version/
</test>

<test check-vault-invalid-header>
  cmd = $pcp -V testvault-invalidheader -l
  expect = /Unexpected vault file format/
</test>

<test check-vault-invalid-version>
  cmd = $pcp -V testvault-invalidversion -l
  expect = /Unexpected vault file format/
</test>
/*
<test check-vault-invalid-itemsize>
  cmd = $pcp -V testvault-invaliditemsize -l
  expect = /invalid key item header size/
</test>
*/
<test check-vault-invalid-itemtype>
  cmd = $pcp -V testvault-invaliditemtype -l
  expect = /invalid key type/
</test>

<test check-vault-invalid-keytype>
  cmd = $pcp -V testvault-invalidkeytype -l
  expect = /contain any keys so far./
</test>