SequenceLogic/Sleds
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
b56ef122dd
Sleds/cppcore/cppcore-test/cppcore-test.cpp

784 lines
34 KiB
C++
Raw Blame History

// Copyright (c) 2014, IOnU Security Inc.
// cppcore-test.cpp : Defines the entry point for the console application.
//
#ifdef WIN32
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT _WIN32_WINNT_WINXP
#include <Rpc.h>
#include <direct.h>
#else
#include <uuid/uuid.h>
#include <unistd.h>
#endif
#include <sstream>
#include <iostream>
#include "eyeutils.h"
#include "../client/syncandmessagedisp.h"
#include "../cppcoreobjects/cloudguardurn.h"
#include "../cppcoreobjects/permissions.h"
#include "../component/pubsubmessage.h"
#include "../../cppjson/jsonobject.h"
#include "../client/vanaccess.h"
#include "../component/slfile.h"
#include "concretenetworksvc.h"
#include "concreteobserver.h"
namespace
{
bool testCGUrn();
bool testPermissions();
bool testCreateUrn(const std::string &urnStr, sequencelogic::CloudGuardURN::URN_TYPE nType);
bool validatePermComplete(const sequencelogic::Permissions &perms);
bool testSamd();
bool testVanAccess();
const char TEST_VAN_DATA1[] = "{ \"_id\":\"urn:sl:000000:::\", \"alias\":\"TEST SERVER\" }";
const char TEST_VAN_DATA2[] = "{ \"_id\":\"urn:sl:FEFEFE:::\", \"alias\":\"TEST SERVER\" }";
const char TEST_OFFICE_DATA1[] = "{\"user\":\"testUser1\",\"fullname\":\"Test User 1\",\"urn\":\"urn:sl:000000:FFFFFFFE:FFFE:\",\"deviceName\":\"Test Device 1\"}";
const char TEST_OFFICE_DATA2[] = "{\"user\":\"testUser2\",\"fullname\":\"Test User 2\",\"urn\":\"urn:sl:FEFEFE:FFFFFFFD:FFFD:\",\"deviceName\":\"Test Device 2\"}";
const char ROOT_DIR1[] = "./test/test_van/subdir";
const char INT_DIR1[] = "./test/test_van_int/subdir";
};
int main(int argc, const char* argv[])
{
int nRetVal = 0;
if (!testCGUrn())
nRetVal = -1;
if (!testPermissions())
nRetVal = -2;
if (!testSamd())
nRetVal = -3;
if (!testVanAccess())
nRetVal = -4;
//getchar();
return nRetVal;
}
namespace
{
bool testCreateUrn(const std::string &urnStr, sequencelogic::CloudGuardURN::URN_TYPE nType)
{
bool bRetVal = true;
sequencelogic::CloudGuardURN tmpUrn(urnStr);
if (nType != sequencelogic::CloudGuardURN::INVALID)
{
if (!(bRetVal = (nType == tmpUrn.getType())))
std::cout << "(CloudGuardURN)ERROR: URN: " << urnStr << " created with wrong type.\n";
}
else if (tmpUrn.getType() != sequencelogic::CloudGuardURN::INVALID)
{
std::cout << "(CloudGuardURN)ERROR: URN: " << urnStr << " should be invalid, but passed construction!\n";
bRetVal = false;
}
return bRetVal;
}
bool validatePermComplete(const sequencelogic::Permissions &perms)
{
bool bRetVal = true;
for (int i = 0; bRetVal && (i < sequencelogic::Permissions::NUM_PERMISSION_KEYS); ++i)
bRetVal = (perms.HasMember(sequencelogic::Permissions::PERMISSION_KEYS[i]));
return bRetVal;
}
bool testCGUrn()
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")INFO: Testing CloudGuardURN...\n";
bool bRetVal = true;
if (6+8+4+12+3 != sequencelogic::CloudGuardURN::NSS_LENGTH)
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: NSS length is incorrect. Length is " << sequencelogic::CloudGuardURN::NSS_LENGTH <<
" should be " << 6+8+4+12+3 << "\n";
bRetVal = false;
}
bRetVal &= testCreateUrn("urn:sl:044356", sequencelogic::CloudGuardURN::URN_TYPE::VAN);
bRetVal &= testCreateUrn("urn:sl:044356:12345678", sequencelogic::CloudGuardURN::URN_TYPE::PMO);
bRetVal &= testCreateUrn("urn:sl:044356:12345678:49BB", sequencelogic::CloudGuardURN::URN_TYPE::PMO_DEVICE);
bRetVal &= testCreateUrn("urn:sl:044356:12345678:49BB:04433607565A", sequencelogic::CloudGuardURN::URN_TYPE::PMO_DEVICE_DOCUMENT);
bRetVal &= testCreateUrn("xurn:sl:04433607-565A-49BB-9267-18E2F0F4E518", sequencelogic::CloudGuardURN::URN_TYPE::INVALID);
bRetVal &= testCreateUrn("urn:xsl:04433607-565A-49BB-9267-18E2F0F4E518", sequencelogic::CloudGuardURN::URN_TYPE::INVALID);
bRetVal &= testCreateUrn("urn:xsl:", sequencelogic::CloudGuardURN::URN_TYPE::INVALID);
bRetVal &= testCreateUrn("urn:xsequencelogic::", sequencelogic::CloudGuardURN::URN_TYPE::INVALID);
bRetVal &= testCreateUrn("urn:xsequencelogic:::", sequencelogic::CloudGuardURN::URN_TYPE::INVALID);
if (!sequencelogic::CloudGuardURN::isDoNotGenerateUUID(GROUP_DOC_DEVICE_ID))
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: " << GROUP_DOC_DEVICE_ID << " is not matched in the 'DoNotGenerateUUID' reg-ex.\n";
bRetVal = false;
}
if (!sequencelogic::CloudGuardURN::isDoNotGenerateUUID(PMO_ALL_ID))
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: " << PMO_ALL_ID << " is not matched in the 'DoNotGenerateUUID' reg-ex.\n";
bRetVal = false;
}
if (!sequencelogic::CloudGuardURN::isDoNotGenerateUUID(TEST_DEVICE_ID))
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: " << TEST_DEVICE_ID << " is not matched in the 'DoNotGenerateUUID' reg-ex.\n";
bRetVal = false;
}
if (!sequencelogic::CloudGuardURN::isDoNotGenerateUUID(BROWSER_DEVICE_ID))
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: " << BROWSER_DEVICE_ID << " is not matched in the 'DoNotGenerateUUID' reg-ex.\n";
bRetVal = false;
}
if (!sequencelogic::CloudGuardURN::isDoNotGenerateUUID(HEADLESS_DEVICE_ID))
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: " << HEADLESS_DEVICE_ID << " is not matched in the 'DoNotGenerateUUID' reg-ex.\n";
bRetVal = false;
}
if (!sequencelogic::CloudGuardURN::isDoNotGenerateUUID(TEST_PMO_ID))
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: " << TEST_PMO_ID << " is not matched in the 'DoNotGenerateUUID' reg-ex.\n";
bRetVal = false;
}
if (!sequencelogic::CloudGuardURN::isDoNotGenerateUUID(TEST_VAN_ID))
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: " << TEST_VAN_ID << " is not matched in the 'DoNotGenerateUUID' reg-ex.\n";
bRetVal = false;
}
// 000000 00:0F are reserved
if (!sequencelogic::CloudGuardURN::isDoNotGenerateUUID("0000000A"))
{
std::cout << "(ClourGuardURN:" << __LINE__ << ")ERROR: 0000000A is not matched in the 'DoNotGenerateUUID' reg-ex.\n";
bRetVal = false;
}
return bRetVal;
}
bool testPermissions()
{
bool bRetVal = true;
std::cout << "(Permissions:" << __LINE__ << ")INFO: Testing Permissions...\n";
/**
* Some setup...
protected static CloudGuardURN
GROUP_DOC_URN = null;
protected static final CloudGuardURN pmoUrn = new CloudGuardURN(TEST_VAN_ID, TEST_PMO_ID, "", "");
protected static Map<CloudGuardURN, Set<CloudGuardURN>>
groupMap = new HashMap<CloudGuardURN, Set<CloudGuardURN>>();
*/
static const std::string GOOD_USER_ID = "123456AB";
static const std::string GOOD_USER_ID2 = "123456CD";
static const std::string GOOD_USER_ID3 = "423456CD";
static const std::string GOOD_USER_ID4 = "423488CD";
static const std::string BAD_USER_ID = "123456AX";
static const std::string BAD_GROUP_ID = "g@foobarxx";
sequencelogic::CloudGuardURNPtr pPmoUrn (new sequencelogic::CloudGuardURN(TEST_VAN_ID, TEST_PMO_ID));
sequencelogic::CloudGuardURNToURNSetMap groupMap;
sequencelogic::CloudGuardURNPtr pGroupDocURN (new sequencelogic::CloudGuardURN(pPmoUrn->getVANID(), pPmoUrn->getPMOID(),
GROUP_DOC_DEVICE_ID, "0123456789AB"));
sequencelogic::CloudGuardURNSet cgUrnSet;
cgUrnSet.insert(sequencelogic::CloudGuardURN(pPmoUrn->getVANID(), GOOD_USER_ID4));
groupMap.insert(std::make_pair(*pGroupDocURN, cgUrnSet));
// Test default construction... Inside a block to let the object
// go out of scope...
{
sequencelogic::Permissions defPermissions;
if (!validatePermComplete(defPermissions))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Default construction of a Permissions object failed.\n";
bRetVal = false;
}
}
// Test copy construction... Inside a block to let the object
// go out of scope...
{
sequencelogic::Permissions defPermissions;
sequencelogic::Permissions newPermissions(defPermissions);
if (!validatePermComplete(newPermissions))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Copy construction of a Permissions object failed.\n";
bRetVal = false;
}
}
// Test construction from flat string...
sequencelogic::PermissionsPtr pFlatPerms = sequencelogic::Permissions::createFromFlatString(GOOD_USER_ID,
std::string("read=owner,")+GOOD_USER_ID+","+GOOD_USER_ID2+","+
sequencelogic::CloudGuardURN::NAMESPACE+pGroupDocURN->toNSS()
+"|write=owner|readAssign=owner|writeAssign=owner");
if (!validatePermComplete(*pFlatPerms))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Flat string creation of a Permissions object failed.\n";
bRetVal = false;
}
else
std::cout << "(Permissions:" << __LINE__ << ")INFO: Flat permissions: " << pFlatPerms->toString() << "\n";
// Test toOrderedString
if (pFlatPerms != NULL)
{
std::string orderedStr = pFlatPerms->toOrderedString();
std::cout << "(Permissions:" << __LINE__ << ")INFO: Ordered string: '" << orderedStr << "'\n";
sequencelogic::JSONObject testObj (orderedStr);
if (!testObj.empty())
{
if (testObj.search(PERMISSION_KEY_OWNER) != NULL)
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Ordered string contains " << PERMISSION_KEY_OWNER << "\n";
bRetVal = false;
}
if (testObj.search(PERMISSION_READ) == NULL)
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Ordered string does not contain " << PERMISSION_READ << "\n";
bRetVal = false;
}
}
else
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Could not create JSONObject from ordered string.\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: toOrderedString not tested due to 'createFromFlatString' error.\n";
// Test digest...
if (pFlatPerms != NULL)
{
sequencelogic::PermissionsPtr pTmpPerms (new sequencelogic::Permissions(*pFlatPerms));
std::string digestStr = pTmpPerms->getSignature(*pPmoUrn);
std::cout << "(Permissions:" << __LINE__ << ")INFO: Sig: " << digestStr << "\n";
pTmpPerms->setAuthority(GOOD_USER_ID);
if (!pTmpPerms->assignRead(GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Cannot assignRead for user '" << GOOD_USER_ID3 << "'\n";
bRetVal = false;
}
digestStr = pTmpPerms->getSignature(*pPmoUrn);
std::cout << "(Permissions:" << __LINE__ << ")INFO: Sig2: " << digestStr << "\n";
pTmpPerms->remove(PERMISSION_READ, GOOD_USER_ID3);
digestStr = pTmpPerms->getSignature(*pPmoUrn);
std::cout << "(Permissions:" << __LINE__ << ")INFO: Sig3: " << digestStr << "\n";
if (digestStr != pFlatPerms->getSignature(*pPmoUrn))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Modified signatute string '" << digestStr << "' doesn't match original '" <<
pFlatPerms->getSignature(*pPmoUrn) << "'\n";
bRetVal = false;
}
std::string orderedPerms = pFlatPerms->getOrderedReferences(*pPmoUrn);
std::string imd5 = sequencelogic::DigestMessage("md5", reinterpret_cast<unsigned const char *>(orderedPerms.c_str()), orderedPerms.length());
std::cout << "(Permissions:" << __LINE__ << ")INFO: slDigest: " << imd5.substr(0, 12) << "\n";
if (imd5.substr(0, 12) != digestStr.substr(0, 12))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Digest substrings do not match.\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: Digest not tested due to 'createFromFlatString' error.\n";
// Test digest matches...
if (pFlatPerms != NULL)
{
sequencelogic::PermissionsPtr pTmpPerms1 (new sequencelogic::Permissions(*pFlatPerms));
sequencelogic::PermissionsPtr pTmpPerms2 (new sequencelogic::Permissions(*pFlatPerms));
// now do similar, but create in such a way that order of things are different
pTmpPerms1->set(PERMISSION_DOORWAY, GOOD_USER_ID3);
pTmpPerms1->set(PERMISSION_DOORWAY, GOOD_USER_ID4);
std::cout << "(Permissions:" << __LINE__ << ")INFO: Tmp perms 1: " << pTmpPerms1->toOrderedString() << "\n";
if (pTmpPerms1->getSignature(*pPmoUrn) == pTmpPerms2->getSignature(*pPmoUrn))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Digest strings match after setting.\n";
bRetVal = false;
}
// different assignment ordering
pTmpPerms2->set(PERMISSION_DOORWAY, GOOD_USER_ID4);
pTmpPerms2->set(PERMISSION_DOORWAY, GOOD_USER_ID3);
std::cout << "(Permissions:" << __LINE__ << ")INFO: Tmp perms 2: " << pTmpPerms2->toOrderedString() << "\n";
if (pTmpPerms1->getSignature(*pPmoUrn) != pTmpPerms2->getSignature(*pPmoUrn))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Digest strings do not match after setting.\n";
bRetVal = false;
}
pTmpPerms2->remove(PERMISSION_DOORWAY, GOOD_USER_ID4);
if (pTmpPerms1->getSignature(*pPmoUrn) == pTmpPerms2->getSignature(*pPmoUrn))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Digest strings match after removing.\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: Digest match not tested due to 'createFromFlatString' error.\n";
// Test digest path...
if (pFlatPerms != NULL)
{
sequencelogic::PermissionsPtr pTmpPerms (new sequencelogic::Permissions(*pFlatPerms));
std::string digestPath = pTmpPerms->getSignaturePath(*pPmoUrn);
std::cout << "(Permissions:" << __LINE__ << ")INFO: DigestPath: " << digestPath << "\n";
if (digestPath == "")
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Digest path is empty.\n";
bRetVal = false;
}
if (digestPath.length() != 12+3)
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Digest path is incorrect length (found " << digestPath.length() <<
", should be " << 12+3 << "\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: Digest match not tested due to 'createFromFlatString' error.\n";
// Test various permission settings...
if (pFlatPerms != NULL)
{
sequencelogic::PermissionsPtr pTmpPerms (new sequencelogic::Permissions(*pFlatPerms));
// Can read?
if (!pTmpPerms->canRead(GOOD_USER_ID2))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canRead returned false for user " << GOOD_USER_ID2 << "\n";
bRetVal = false;
}
// Can group read?
if (!pTmpPerms->canRead(std::string(sequencelogic::CloudGuardURN::NAMESPACE) + pGroupDocURN->toNSS()))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canRead returned false for user " << sequencelogic::CloudGuardURN::NAMESPACE <<
pGroupDocURN->toNSS() << "\n";
bRetVal = false;
}
// Can write?
if (!pTmpPerms->canWrite(GOOD_USER_ID))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canWrite returned false for user " << GOOD_USER_ID << "\n";
bRetVal = false;
}
// Can not write?
if (pTmpPerms->canWrite(GOOD_USER_ID2))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canWrite returned true for user " << GOOD_USER_ID2 << "\n";
bRetVal = false;
}
// Can assign read?
pTmpPerms->setAuthority(GOOD_USER_ID);
if (!pTmpPerms->assignRead(GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assignRead returned false for user " << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
if (!pTmpPerms->canRead(GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canRead returned false for user " << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
if (!pTmpPerms->assignRead(std::string("-")+GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assignRead returned false for user -" << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
if (pTmpPerms->canRead(GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canRead returned true for user " << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
// Can assign write?
pTmpPerms->setAuthority(GOOD_USER_ID);
pTmpPerms->set("admin", GOOD_USER_ID);
if (!sequencelogic::Permissions::assign(*pTmpPerms, "writeAssign", GOOD_USER_ID, std::string("+")+GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assign(writeAssign) returned false for user +" << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
if (!sequencelogic::Permissions::can(*pTmpPerms, "writeAssign", GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: can(writeAssign) returned false for user " << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
if (!sequencelogic::Permissions::assign(*pTmpPerms, "writeAssign", GOOD_USER_ID, std::string("-")+GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assign returned false for user -" << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
if (sequencelogic::Permissions::can(*pTmpPerms, "writeAssign", GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: can(writeAssign) returned true for user " << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
pTmpPerms = NULL;
pTmpPerms = sequencelogic::PermissionsPtr(new sequencelogic::Permissions(*pFlatPerms));
// Can assign other?
pTmpPerms->setAuthority(GOOD_USER_ID2);
pTmpPerms->set(std::string(PERMISSION_READ) + PERMISSION_ASSIGNMENT_SUFFIX, GOOD_USER_ID2);
pTmpPerms->assignRead(GOOD_USER_ID3);
if (!pTmpPerms->canRead(GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canRead returned false for user " << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
pTmpPerms = NULL;
pTmpPerms = sequencelogic::PermissionsPtr(new sequencelogic::Permissions(*pFlatPerms));
// Test assign admin...
pTmpPerms->setAuthority(GOOD_USER_ID);
pTmpPerms->set("admin", GOOD_USER_ID);
if (!sequencelogic::Permissions::assign(*pTmpPerms, "admin", GOOD_USER_ID, "+owner"))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assign(admin) returned false for user " << GOOD_USER_ID << "\n";
bRetVal = false;
}
if (!pTmpPerms->isAdmin("owner"))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: isAdmin returned false for user owner\n";
bRetVal = false;
}
if (!pTmpPerms->assignAdmin("-owner"))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assignAdmin returned false for user -owner\n";
bRetVal = false;
}
if (pTmpPerms->isAdmin("owner"))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: isAdmin returned true for user owner\n";
bRetVal = false;
}
pTmpPerms->set("admin", GOOD_USER_ID2);
if (!sequencelogic::Permissions::assign(*pTmpPerms, "writeAssign", GOOD_USER_ID2, GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assign(writeAssign) returned false for user -" << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
pTmpPerms = NULL;
pTmpPerms = sequencelogic::PermissionsPtr(new sequencelogic::Permissions(*pFlatPerms));
// Test not assign...
pTmpPerms->setAuthority(GOOD_USER_ID2);
if (pTmpPerms->assignWrite(GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assignWrite returned true for user " << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
if (pTmpPerms->canWrite(GOOD_USER_ID3))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canWrite returned true for user " << GOOD_USER_ID3 << "\n";
bRetVal = false;
}
pTmpPerms = NULL;
pTmpPerms = sequencelogic::PermissionsPtr(new sequencelogic::Permissions(*pFlatPerms));
{
// Test merge...
pTmpPerms->setAuthority(GOOD_USER_ID);
sequencelogic::PermissionsPtr pOtherPerms (new sequencelogic::Permissions(sequencelogic::JSONObject("{\"write\":[\"" + GOOD_USER_ID4 + "\"]}")));
sequencelogic::PermissionsPtr pMergedPerms = pTmpPerms->merge(*pOtherPerms);
if (pMergedPerms->getOwner() == "")
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: getOwner returned '' for merged permissions.\n";
bRetVal = false;
}
if (pMergedPerms->getAuthority() == "")
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: getAuthority returned '' for merged permissions.\n";
bRetVal = false;
}
if (!pMergedPerms->canWrite(GOOD_USER_ID4))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canWrite returned false for user " << GOOD_USER_ID4 << "\n";
bRetVal = false;
}
std::cout << "(Permissions:" << __LINE__ << ")INFO: Merged: " << pMergedPerms->toString() << "\n";
}
pTmpPerms = NULL;
pTmpPerms = sequencelogic::Permissions::createFromParent(sequencelogic::JSONObject());
// Test cannot read...
if (pTmpPerms->canRead(GOOD_USER_ID4))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: canRead returned false for user " << GOOD_USER_ID4 << "\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: Various permission settings not tested due to 'createFromFlatString' error.\n";
// Test bad perm/user ID
if (pFlatPerms != NULL)
{
sequencelogic::PermissionsPtr pTmpPerms (new sequencelogic::Permissions(*pFlatPerms));
pTmpPerms->setAuthority(GOOD_USER_ID);
if (sequencelogic::Permissions::assign(*pTmpPerms, "foo", pTmpPerms->getAuthority(), GOOD_USER_ID))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assign(foo) returned true for user " << GOOD_USER_ID << "\n";
bRetVal = false;
}
if (pTmpPerms->assignRead(BAD_USER_ID))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assignRead returned true for user " << BAD_USER_ID << "\n";
bRetVal = false;
}
if (pTmpPerms->assignRead(BAD_GROUP_ID))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: assignRead returned true for user " << BAD_GROUP_ID << "\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: Bad permissions/user ID not tested due to 'createFromFlatString' error.\n";
// Test type
if (pFlatPerms != NULL)
{
sequencelogic::PermissionsPtr pTmpPerms (new sequencelogic::Permissions(*pFlatPerms));
if (pTmpPerms->getType() != "file")
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: getType did not return file.\n";
bRetVal = false;
}
pTmpPerms->setType("group");
if (pTmpPerms->getType() != "group")
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: getType did not return group.\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: Type not tested due to 'createFromFlatString' error.\n";
// Test update members
if (pFlatPerms != NULL)
{
sequencelogic::PermissionsPtr pTmpPerms (new sequencelogic::Permissions(*pFlatPerms));
if (pTmpPerms->HasMember(PERMISSION_MEMBERS_KEY))
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Permission object already has member " << PERMISSION_MEMBERS_KEY << ".\n";
bRetVal = false;
}
sequencelogic::CloudGuardURNSet tmpSet;
pTmpPerms->updateMembers(*pPmoUrn, groupMap, tmpSet);
if (tmpSet.size() == 0)
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: updateMembers failed.\n";
bRetVal = false;
}
else if (tmpSet.size() != 3)
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: updateMembers returned incorrect number of members.\n";
bRetVal = false;
}
else if (tmpSet.find(sequencelogic::CloudGuardURN(TEST_VAN_ID, GOOD_USER_ID4)) == tmpSet.end())
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: Cannot find member " << GOOD_USER_ID4 << " in updated URN set.\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: Update members not tested due to 'createFromFlatString' error.\n";
// Test permitted items...
if (pFlatPerms != NULL)
{
sequencelogic::PermissionsPtr pTmpPerms (new sequencelogic::Permissions(*pFlatPerms));
sequencelogic::JSONArray permittedItems;
pTmpPerms->getPermittedItems(*pPmoUrn, permittedItems);
if (permittedItems.empty())
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: getPermittedItems failed.\n";
bRetVal = false;
}
else if (permittedItems.getnumelements() != 4)
{
std::cout << "(Permissions:" << __LINE__ << ")ERROR: getPermittedItems returned incorrect number of items (" << permittedItems.getnumelements() << ").\n";
bRetVal = false;
}
}
else
std::cout << "(Permissions:" << __LINE__ << ")WARNING: Permitted items not tested due to 'createFromFlatString' error.\n";
return bRetVal;
}
bool testSamd()
{
bool bRetVal = true;
ConcreteNetworkSvcs netSvcs;
ConcreteObserver observer;
sequencelogic::JSONObject tmpObj(TEST_OFFICE_DATA1);
sequencelogic::SyncAndMessageDispatch samd("", tmpObj.getJSONString("urn").c_str(), &observer, &netSvcs);
samd.subscribeAndDispatch();
return bRetVal;
}
bool testVanAccess()
{
bool bRetVal = true;
// Test the van access code!
sequencelogic::VanAccess vanAccess;
#ifdef WIN32
_rmdir(ROOT_DIR1);
#else
rmdir(ROOT_DIR1);
#endif
vanAccess.setVANDataRootDirectory(ROOT_DIR1);
vanAccess.setVANInternalDirectory(INT_DIR1);
if (vanAccess.getVANDataRootDirectory().find( ROOT_DIR1) != 0)
{
bRetVal = false;
std::cout << "(VanAccess:" << __LINE__ << ")ERROR: Root dir for VAN incorrectly stored as '" <<
vanAccess.getVANDataRootDirectory() << "'; it should be " << ROOT_DIR1 << std::endl;
}
if (bRetVal)
{
std::cout << "(VanAccess:" << __LINE__ << ")INFO: Root dir set/get passed." << std::endl;
// Create some VANs in the VAN dir...
sequencelogic::JSONObject van1(TEST_VAN_DATA1);
sequencelogic::JSONObject van2(TEST_VAN_DATA2);
sequencelogic::JSONObject office1(TEST_OFFICE_DATA1);
sequencelogic::JSONObject office2(TEST_OFFICE_DATA2);
std::stringstream tmpDir;
tmpDir << ROOT_DIR1 << sequencelogic::File::DIR_SEP << van1.getJSONString("alias", "xxx") << sequencelogic::File::DIR_SEP <<
sequencelogic::CloudGuardURN(van1.getJSONString("_id")).getVANID() << sequencelogic::File::DIR_SEP;
std::string tmpFileStr = tmpDir.str();
sequencelogic::File tmpFile (tmpFileStr);
if (!vanAccess.installVAN(TEST_VAN_DATA1))
{
bRetVal = false;
std::cout << "(VanAccess:" << __LINE__ << ")ERROR: Failed to install VAN '" <<
TEST_VAN_DATA1 << std::endl;
}
tmpFileStr += sequencelogic::CloudGuardURN(office1.getJSONString("urn")).getPMOID();
tmpFileStr += sequencelogic::File::DIR_SEP;
tmpFile.setFilename(tmpFileStr);
tmpFile.mkdirs();
office1.SaveToFile(tmpFileStr + "sl-keyring.iks.public");
tmpDir.str("");
tmpDir << ROOT_DIR1 << sequencelogic::File::DIR_SEP << van1.getJSONString("alias", "xxx") << sequencelogic::File::DIR_SEP <<
sequencelogic::CloudGuardURN(van1.getJSONString("_id")).getVANID() << sequencelogic::File::DIR_SEP;
tmpFileStr = tmpDir.str();
tmpFileStr += sequencelogic::CloudGuardURN(office2.getJSONString("urn")).getPMOID();
tmpFileStr += sequencelogic::File::DIR_SEP;
tmpFile.setFilename(tmpFileStr);
tmpFile.mkdirs();
office2.SaveToFile(tmpFileStr + "sl-keyring.iks.public");
tmpDir.str("");
tmpDir << ROOT_DIR1 << sequencelogic::File::DIR_SEP << van2.getJSONString("alias", "xxx") << sequencelogic::File::DIR_SEP <<
sequencelogic::CloudGuardURN(van2.getJSONString("_id")).getVANID() << sequencelogic::File::DIR_SEP;
tmpFileStr = tmpDir.str();
tmpFile.setFilename(tmpFileStr);
if (!vanAccess.installVAN(TEST_VAN_DATA2))
{
bRetVal = false;
std::cout << "(VanAccess:" << __LINE__ << ")ERROR: Failed to install VAN '" <<
TEST_VAN_DATA2 << std::endl;
}
tmpFileStr += sequencelogic::CloudGuardURN(office1.getJSONString("urn")).getPMOID();
tmpFileStr += sequencelogic::File::DIR_SEP;
tmpFile.setFilename(tmpFileStr);
tmpFile.mkdirs();
office1.SaveToFile(tmpFileStr + "sl-keyring.iks.public");
tmpDir.str("");
tmpDir << ROOT_DIR1 << sequencelogic::File::DIR_SEP << van2.getJSONString("alias", "xxx") << sequencelogic::File::DIR_SEP <<
sequencelogic::CloudGuardURN(van2.getJSONString("_id")).getVANID() << sequencelogic::File::DIR_SEP;
tmpFileStr = tmpDir.str();
tmpFileStr += sequencelogic::CloudGuardURN(office2.getJSONString("urn")).getPMOID();
tmpFileStr += sequencelogic::File::DIR_SEP;
tmpFile.setFilename(tmpFileStr);
tmpFile.mkdirs();
office2.SaveToFile(tmpFileStr + "sl-keyring.iks.public");
}
if (vanAccess.getVANInternalDirectory().find(INT_DIR1) != 0)
{
bRetVal = false;
std::cout << "(VanAccess:" << __LINE__ << ")ERROR: Root dir for VAN incorrectly stored as '" <<
vanAccess.getVANInternalDirectory() << "'; it should be " << INT_DIR1 << std::endl;
}
if (bRetVal)
std::cout << "(VanAccess:" << __LINE__ << ")INFO: Internal dir set/get passed." << std::endl;
if (!vanAccess.setCurrentVan(TEST_VAN_DATA1))
{
bRetVal = false;
std::cout << "(VanAccess:" << __LINE__ << ")ERROR: Cannot set current VAN to " << TEST_VAN_DATA1 << std::endl;
}
else
std::cout << "(VanAccess:" << __LINE__ << ")INFO: Set current VAN passed." << std::endl;
if (vanAccess.getCurrentVan() != TEST_VAN_DATA1)
{
bRetVal = false;
std::cout << "(VanAccess:" << __LINE__ << ")ERROR: Get current VAN incorrectly stored as '" <<
vanAccess.getCurrentVan() << "; it should be " << TEST_VAN_DATA1 << std::endl;
}
else
std::cout << "(VanAccess:" << __LINE__ << ")INFO: Get current VAN passed." << std::endl;
vanAccess.setCurrentVan(TEST_VAN_DATA2);
sequencelogic::JSONArray provisionedVANs(vanAccess.getProvisionedVANs());
std::cout << "(VanAccess:" << __LINE__ << ")INFO: Provisioned VANs:\n";
for (int i = 0; i < provisionedVANs.getnumelements(); ++i)
{
const sequencelogic::JSONObject &vanObj = reinterpret_cast<const sequencelogic::JSONObject &>(provisionedVANs[i]);
std::cout << "(VanAccess:" << __LINE__ << ")INFO: " << vanObj << "\n";
sequencelogic::JSONArray users(vanAccess.getProvisionedUsers(vanObj.toString()));
std::cout << "(VanAccess:" << __LINE__ << ")INFO: Provisioned users:\n";
for (int j = 0; j < users.getnumelements(); ++j)
std::cout << "(VanAccess:" << __LINE__ << ")INFO: " << reinterpret_cast<const sequencelogic::JSONObject &>(users[j]) << "\n";
}
vanAccess.wipe();
sequencelogic::JSONObject van1Obj(TEST_VAN_DATA1);
std::stringstream testVANPath;
testVANPath << ROOT_DIR1 << sequencelogic::File::DIR_SEP <<
van1Obj.getJSONString("alias", "xxx") << sequencelogic::File::DIR_SEP <<
sequencelogic::CloudGuardURN(van1Obj.getJSONString("_id")).getVANID() << sequencelogic::File::DIR_SEP;
sequencelogic::File testVANFile(testVANPath.str());
if (testVANFile.exists())
{
bRetVal = false;
std::cout << "(VanAccess:" << __LINE__ << ")ERROR: VAN directory " << testVANFile.getAbsolutePath() << " still exists after wipe!" << std::endl;
}
else
std::cout << "(VanAccess:" << __LINE__ << ")INFO: Wipe VANs passed." << std::endl;
return bRetVal;
}
}
Reference in New Issue View Git Blame Copy Permalink